diff --git a/.gitea/workflows/docker-rh8-build-test.yml b/.gitea/workflows/docker-rh8-build-test.yml index 3d070f71e..9bb09949b 100644 --- a/.gitea/workflows/docker-rh8-build-test.yml +++ b/.gitea/workflows/docker-rh8-build-test.yml @@ -15,13 +15,14 @@ jobs: steps: - name: Clone repository run: | + git lfs install --skip-smudge echo Cloning ${{ github.ref_name }} git clone https://${{secrets.GITHUB_TOKEN}}@gitea.psi.ch/${{ github.repository }}.git --branch=${{ github.ref_name }} . - name: Build library run: | mkdir build && cd build - cmake .. -DSLS_USE_PYTHON=ON -DSLS_USE_TESTS=ON -DSLS_USE_SIMULATOR=ON + cmake .. -DSLS_USE_PYTHON=ON -DSLS_USE_TESTS=ON -DSLS_USE_SIMULATOR=ON -DSLS_USE_MATTERHORN=ON make -j 2 - name: C++ unit tests diff --git a/.gitea/workflows/docker-rh9-build-test.yml b/.gitea/workflows/docker-rh9-build-test.yml index 2783d69ec..7d2fbb400 100644 --- a/.gitea/workflows/docker-rh9-build-test.yml +++ b/.gitea/workflows/docker-rh9-build-test.yml @@ -19,7 +19,7 @@ jobs: - name: Build library run: | mkdir build && cd build - cmake .. -DSLS_USE_PYTHON=ON -DSLS_USE_TESTS=ON -DSLS_USE_SIMULATOR=ON + cmake .. -DSLS_USE_PYTHON=ON -DSLS_USE_TESTS=ON -DSLS_USE_SIMULATOR=ON -DSLS_USE_MATTERHORN=ON make -j 2 - name: C++ unit tests diff --git a/.github/workflows/build_documentation.yml b/.github/workflows/build_documentation.yml index ebbce9606..458084c0a 100644 --- a/.github/workflows/build_documentation.yml +++ b/.github/workflows/build_documentation.yml @@ -52,7 +52,7 @@ jobs: fi - name: Install System Packages - uses: awalsh128/cache-apt-pkgs-action@latest + uses: awalsh128/cache-apt-pkgs-action@v1.6.1 with: packages: libhdf5-dev doxygen libfmt-dev version: 1.0 diff --git a/.github/workflows/cmake.yaml b/.github/workflows/cmake.yaml index 1c4d7b0f6..b90214279 100644 --- a/.github/workflows/cmake.yaml +++ b/.github/workflows/cmake.yaml @@ -21,7 +21,8 @@ jobs: cache: 'pip' - run: pip install pytest numpy colorama - - uses: awalsh128/cache-apt-pkgs-action@latest + # using a stable action version instead of latest to create/restore cache for now + - uses: awalsh128/cache-apt-pkgs-action@v1.6.1 with: packages: libhdf5-dev qtbase5-dev qt5-qmake libqt5svg5-dev libpng-dev libtiff-dev libfmt-dev version: 1.0 @@ -37,7 +38,9 @@ jobs: -DSLS_USE_PYTHON=ON \ -DSLS_USE_HDF5=ON \ -DSLS_USE_GUI=ON \ - -DSLS_USE_MOENCH=ON + -DSLS_USE_MOENCH=ON \ + -DSLS_TREAT_WARNINGS_AS_ERRORS=ON \ + -DSLS_USE_MATTERHORN=ON - name: Build # Build your program with the given configuration diff --git a/.github/workflows/run_tests.yaml b/.github/workflows/run_tests.yaml index 96d04205e..f5ee18c63 100644 --- a/.github/workflows/run_tests.yaml +++ b/.github/workflows/run_tests.yaml @@ -20,7 +20,8 @@ jobs: cache: 'pip' - run: pip install pytest numpy colorama pyzmq - - uses: awalsh128/cache-apt-pkgs-action@latest + # using a stable action version instead of latest to create/restore cache for now + - uses: awalsh128/cache-apt-pkgs-action@v1.6.1 with: packages: libhdf5-dev libfmt-dev version: 1.0 diff --git a/CMakeLists.txt b/CMakeLists.txt index 8830eb86e..5ea532cee 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -236,6 +236,7 @@ option(SLS_USE_MOENCH "compile zmq and post processing for Moench" OFF) option(SLS_USE_JUNGFRAU "compile post processing for Jungfrau" OFF) option(SLS_USE_MATTERHORN "compile matterhorn server" OFF) option(SLS_INSTALL_VERSIONED_BINARIES "Add version number to binaries on install" OFF) #Needed for multi version RPM +option(SLS_TREAT_WARNINGS_AS_ERRORS "Treat warnings as errors" OFF) #Convenience option to switch off defaults when building Moench binaries only option(SLS_BUILD_ONLY_MOENCH "compile only Moench" OFF) @@ -249,6 +250,18 @@ if(SLS_BUILD_ONLY_MOENCH) set(SLS_USE_MOENCH ON CACHE BOOL "Enable" FORCE) endif() +option(SLS_BUILD_ONLY_MATTERHORN "compile only Matterhorn" OFF) +if(SLS_BUILD_ONLY_MATTERHORN) + message(STATUS "Build MATTERHORN server only!") + set(SLS_BUILD_SHARED_LIBRARIES OFF CACHE BOOL "Disabled for MATTERHORN_ONLY" FORCE) + set(SLS_USE_TEXTCLIENT OFF CACHE BOOL "Disabled for MATTERHORN_ONLY" FORCE) + set(SLS_USE_DETECTOR ON CACHE BOOL "Disabled for MATTERHORN_ONLY" FORCE) + set(SLS_USE_RECEIVER OFF CACHE BOOL "Disabled for MATTERHORN_ONLY" FORCE) + set(SLS_USE_RECEIVER_BINARIES OFF CACHE BOOL "Disabled for MATTERHORN_ONLY" FORCE) + set(SLS_USE_SERVER ON CACHE BOOL "Enable building cpp server" FORCE) + set(SLS_USE_MATTERHORN ON CACHE BOOL "Enable Matterhorn" FORCE) +endif() + #Convenience option to switch off defaults when building Jungfrau binaries only option(SLS_BUILD_ONLY_JUNGFRAU "compile only Jungfrau" OFF) if(SLS_BUILD_ONLY_JUNGFRAU) @@ -347,7 +360,9 @@ if (NOT TARGET slsProjectWarnings) -Wno-missing-field-initializers) endif() - + if(SLS_TREAT_WARNINGS_AS_ERRORS) + target_compile_options(slsProjectWarnings INTERFACE -Werror) + endif() endif() @@ -376,6 +391,10 @@ if (NOT TARGET slsProjectCSettings) target_compile_options(slsProjectCSettings INTERFACE -fsanitize=address,undefined -fno-omit-frame-pointer) target_link_libraries(slsProjectCSettings INTERFACE -fsanitize=address,undefined) endif() + + if(SLS_TREAT_WARNINGS_AS_ERRORS) + target_compile_options(slsProjectCSettings INTERFACE -Werror) + endif() endif() @@ -433,14 +452,15 @@ if (SLS_USE_GUI) add_subdirectory(slsDetectorGui) endif (SLS_USE_GUI) -if (SLS_USE_MATTERHORN) - add_subdirectory(slsDetectorServers/matterhornServer) -endif() - if (SLS_USE_SIMULATOR) add_subdirectory(slsDetectorServers) endif (SLS_USE_SIMULATOR) +# cant add_subdirectory twice +if (SLS_USE_MATTERHORN AND !SLS_USE_SIMULATOR) + add_subdirectory(slsDetectorServers/matterhornServer) +endif() + if (SLS_USE_PYTHON) find_package (Python 3.8 COMPONENTS Interpreter Development.Module REQUIRED) set(PYBIND11_FINDPYTHON ON) # Needed for RH8 @@ -483,13 +503,15 @@ if(SLS_BUILD_DOCS) add_subdirectory(docs) endif(SLS_BUILD_DOCS) -if(SLS_USE_MOENCH) +if(SLS_USE_MOENCH OR SLS_USE_JUNGFRAU) add_subdirectory(slsDetectorCalibration/tiffio) +endif() + +if(SLS_USE_MOENCH) add_subdirectory(slsDetectorCalibration/moenchExecutables) endif(SLS_USE_MOENCH) if(SLS_USE_JUNGFRAU) - add_subdirectory(slsDetectorCalibration/tiffio) add_subdirectory(slsDetectorCalibration/jungfrauExecutables) endif(SLS_USE_JUNGFRAU) diff --git a/RELEASE.md b/RELEASE.md index c67a67438..11563b7af 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -62,8 +62,14 @@ support for building rpms removed unused function readDataFile/writeDataFile from file_utils.h +changed api: datastream=>udp_datastream, set/getDatastream=>set/getUDPDatastream +also implemetned for jungfrau, moench at receiver side (top/bottom) + added rx_streamdummyheader to send the zmq dummy header any time. Allows pre-configuring zmq processing before acq begins. +allow disabling one UDP interface in the receiver. + +setting number of UDP interfaces can only be set at detector level and not at module level. (individual modules) 2 On-board Detector Server Compatibility ========================================== diff --git a/etc/generate_registerdefs.py b/etc/generate_registerdefs.py index 91178b0e3..aaaaa9720 100644 --- a/etc/generate_registerdefs.py +++ b/etc/generate_registerdefs.py @@ -32,23 +32,47 @@ def argument_parser(): # TODO: should be configurable header = r""" +#pragma once // clang-format off #include "RegisterHelperStructs.hpp" namespace sls { + + +namespace Reg { + /// @brief Enum for IP cores, value are adresses enum class IPCore : uint32_t { - MH_RO_SM_AXI = 0, // dummy adresses for now - FHDR_AXI = 1, - AURORA_STATUS = 2, - AURORA_STATUS2 = 3, - PACKETIZERREG = 4, - UNKNOWN = 5 + MH_RO_SM_AXI = 0xB0010000, + FHDR_AXI = 0xB0011000, + AURORA_STATUS = 0xB0014000, + AURORA_STATUS2 = 0xB0015000, + PACKETIZERREG = 0x00000000, // TODO: fill in correct address + UNKNOWN = 0x00000000 // dont know yet }; + +constexpr size_t IPCORE_REGISTER_BLOCK_SIZE = + 0x1000; // size of each IP core address space in bytes // TODO: maybe add in + // other file definitions + +// clang-format off + """ postpend = r""" +constexpr RegisterField ModuleRow{ + Frame_HDR_ModCoord_LSB_Reg, 0, 0xffff}; + +constexpr RegisterField ModuleCol{ + Frame_HDR_ModCoord_LSB_Reg, 16, 0xffff}; + +constexpr RegisterField ModuleCoordz{ + Frame_HDR_ModCoord_MSB_Reg, 0, 0xffff}; + +constexpr RegisterField ModuleIndex{ + Frame_HDR_ModCoord_MSB_Reg, 16, 0xffff}; +} // namespace Reg } // namespace sls // clang-format on """ diff --git a/etc/updateAPIVersion.py b/etc/updateAPIVersion.py index 84b160384..74c1289ec 100644 --- a/etc/updateAPIVersion.py +++ b/etc/updateAPIVersion.py @@ -20,8 +20,8 @@ API_FILE = ROOT_DIR / "slsSupportLib/include/sls/versionAPI.h" VERSION_FILE = ROOT_DIR / "VERSION" parser = argparse.ArgumentParser(description = 'updates API version') -parser.add_argument('api_module_name', choices=["APILIB", "APIRECEIVER", "APICTB", "APIGOTTHARD2", "APIMOENCH", "APIEIGER", "APIXILINXCTB", "APIJUNGFRAU", "APIMYTHEN3"], help = 'module name to change api version options are: ["APILIB", "APIRECEIVER", "APICTB", "APIGOTTHARD2", "APIMOENCH", "APIEIGER", "APIXILINXCTB", "APIJUNGFRAU", "APIMYTHEN3"]') -parser.add_argument('api_dir', help = 'Relative or absolute path to the module code') +parser.add_argument('api_module_name', choices=["APILIB", "APIRECEIVER", "APICTB", "APIGOTTHARD2", "APIMOENCH", "APIEIGER", "APIXILINXCTB", "APIJUNGFRAU", "APIMYTHEN3", "APIMATTERHORN"], help = 'module name to change api version options are: ["APILIB", "APIRECEIVER", "APICTB", "APIGOTTHARD2", "APIMOENCH", "APIEIGER", "APIXILINXCTB", "APIJUNGFRAU", "APIMYTHEN3", "APIMATTERHORN"]') +parser.add_argument('api_dirs', nargs="+", help = 'Relative or absolute paths to the module code') def update_api_file(new_api : str, api_module_name : str, api_file_name : str): @@ -36,21 +36,22 @@ def update_api_file(new_api : str, api_module_name : str, api_file_name : str): else: api_file.write(line) -def get_latest_modification_date(directory : str): +def get_latest_modification_date(directories : list[str]): latest_time = 0 latest_date = None - for root, dirs, files in os.walk(directory): - for file in files: - if file.endswith(".o"): - continue - full_path = os.path.join(root, file) - try: - mtime = os.path.getmtime(full_path) - if mtime > latest_time: - latest_time = mtime - except FileNotFoundError: - continue + for directory in directories: + for root, dirs, files in os.walk(directory): + for file in files: + if file.endswith(".o"): + continue + full_path = os.path.join(root, file) + try: + mtime = os.path.getmtime(full_path) + if mtime > latest_time: + latest_time = mtime + except FileNotFoundError: + continue latest_date = datetime.fromtimestamp(latest_time).strftime("%y%m%d") @@ -74,9 +75,9 @@ if __name__ == "__main__": args = parser.parse_args() - api_dir = ROOT_DIR / args.api_dir + api_dirs = [ROOT_DIR / api_dir for api_dir in args.api_dirs] - update_api_version(args.api_module_name, api_dir) + update_api_version(args.api_module_name, api_dirs) diff --git a/pyctbgui/pyctbgui/services/Acquisition.py b/pyctbgui/pyctbgui/services/Acquisition.py index b32b8a659..dcf06707d 100644 --- a/pyctbgui/pyctbgui/services/Acquisition.py +++ b/pyctbgui/pyctbgui/services/Acquisition.py @@ -133,6 +133,7 @@ class AcquisitionTab(QtWidgets.QWidget): self.view.labelDigital.setDisabled(True) self.view.labelTransceiver.setDisabled(True) self.view.spinBoxTransceiver.setDisabled(True) + self.plotTab.enableallCounterCheckBox(False) case readoutMode.DIGITAL_ONLY: self.view.spinBoxAnalog.setDisabled(True) self.view.labelAnalog.setDisabled(True) @@ -140,6 +141,7 @@ class AcquisitionTab(QtWidgets.QWidget): self.view.labelDigital.setEnabled(True) self.view.labelTransceiver.setDisabled(True) self.view.spinBoxTransceiver.setDisabled(True) + self.plotTab.enableallCounterCheckBox(False) case readoutMode.ANALOG_AND_DIGITAL: self.view.spinBoxAnalog.setEnabled(True) self.view.labelAnalog.setEnabled(True) @@ -147,6 +149,7 @@ class AcquisitionTab(QtWidgets.QWidget): self.view.labelDigital.setEnabled(True) self.view.labelTransceiver.setDisabled(True) self.view.spinBoxTransceiver.setDisabled(True) + self.plotTab.enableallCounterCheckBox(False) case readoutMode.TRANSCEIVER_ONLY: self.view.spinBoxAnalog.setDisabled(True) self.view.labelAnalog.setDisabled(True) @@ -154,6 +157,7 @@ class AcquisitionTab(QtWidgets.QWidget): self.view.labelDigital.setDisabled(True) self.view.labelTransceiver.setEnabled(True) self.view.spinBoxTransceiver.setEnabled(True) + self.plotTab.enableallCounterCheckBox(self.plotTab.view.radioButtonImage.isChecked()) # enable counter checkboxes for matterhorn case _: self.view.spinBoxAnalog.setDisabled(True) self.view.labelAnalog.setDisabled(True) @@ -161,6 +165,7 @@ class AcquisitionTab(QtWidgets.QWidget): self.view.labelDigital.setEnabled(True) self.view.labelTransceiver.setEnabled(True) self.view.spinBoxTransceiver.setEnabled(True) + self.plotTab.enableallCounterCheckBox(self.plotTab.view.radioButtonImage.isChecked()) # enable counter checkboxes for matterhorn self.view.comboBoxROMode.currentIndexChanged.connect(self.setReadOut) self.view.spinBoxAnalog.editingFinished.connect(self.setAnalog) diff --git a/pyctbgui/pyctbgui/services/Plot.py b/pyctbgui/pyctbgui/services/Plot.py index a14ef1a0a..688265484 100644 --- a/pyctbgui/pyctbgui/services/Plot.py +++ b/pyctbgui/pyctbgui/services/Plot.py @@ -4,10 +4,10 @@ import random from pathlib import Path import numpy as np -from PyQt5 import QtWidgets, QtGui, uic +from PyQt5 import QtWidgets, QtGui, QtCore, uic from aare import transform, ReadoutMode -from aare._aare import Matterhorn10, Matterhorn02, Moench04 +from aare._aare import Matterhorn10, Matterhorn02, Moench04, Moench05 import pyqtgraph as pg from pyctbgui.utils import recordOrApplyPedestal @@ -43,6 +43,7 @@ class PlotTab(QtWidgets.QWidget): self.pedestalApply: bool = True self.__acqFrames = None self.logger = logging.getLogger('PlotTab') + self.plotSplitter = None def setup_ui(self): self.signalsTab = self.mainWindow.signalsTab @@ -51,10 +52,17 @@ class PlotTab(QtWidgets.QWidget): self.adcTab = self.mainWindow.adcTab self.initializeColorMaps() + # TODO use list comprehension + self.checkBoxCounters = [self.view.checkBoxCounter0, self.view.checkBoxCounter1, self.view.checkBoxCounter2, self.view.checkBoxCounter3] + + for checkBox in self.checkBoxCounters: + checkBox.setChecked(False) + checkBox.setEnabled(False) + self.imagePlots = ( self.mainWindow.plotAnalogImage, self.mainWindow.plotDigitalImage, - self.mainWindow.plotTransceiverImage, + self.transceiverTab.transceiverImageViews, ) def connect_ui(self): @@ -93,12 +101,54 @@ class PlotTab(QtWidgets.QWidget): self.view.radioButtonFixed.clicked.connect(partial(self.setColorRangeMode, Defines.colorRange.fixed)) self.view.radioButtonCenter.clicked.connect(partial(self.setColorRangeMode, Defines.colorRange.center)) - for plot in self.imagePlots: - plot.scene.sigMouseMoved.connect(partial(self.showPlotValues, plot)) - plot.getHistogramWidget().item.sigLevelChangeFinished.connect(partial(self.handleHistogramChange, plot)) + for index, checkBox in enumerate(self.checkBoxCounters): + checkBox.stateChanged.connect(partial(self.displayCounter, index)) + + # show image Values for analog image + nMaxY = lambda : self.mainWindow.nAnalogRows + nMaxX = lambda : self.mainWindow.nAnalogCols + frame = lambda : self.mainWindow.analog_frame + plot = self.mainWindow.plotAnalogImage + plot.scene.sigMouseMoved.connect(partial(self.showPlotValues, plot, nMaxX, nMaxY, frame)) + plot.getHistogramWidget().item.sigLevelChangeFinished.connect(partial(self.handleHistogramChange, plot)) + + # show image Values for digital image + nMaxY = lambda : self.mainWindow.nDigitalRows + nMaxX = lambda : self.mainWindow.nDigitalCols + frame = lambda : self.mainWindow.digital_frame + plot = self.mainWindow.plotDigitalImage + plot.scene.sigMouseMoved.connect(partial(self.showPlotValues, plot, nMaxX, nMaxY, frame)) + plot.getHistogramWidget().item.sigLevelChangeFinished.connect(partial(self.handleHistogramChange, plot)) + + # show image Values for transceiver image + nMaxY = lambda : self.transceiverTab.nTransceiverRows + nMaxX = lambda : self.transceiverTab.nTransceiverCols + + for index, image_view in enumerate(self.transceiverTab.transceiverImageViews): + frame = lambda : image_view.getImageItem().image + image_view.scene.sigMouseMoved.connect(partial(self.showPlotValues, image_view, nMaxX, nMaxY, frame)) + image_view.getHistogramWidget().item.sigLevelChangeFinished.connect(partial(self.handleHistogramChange, image_view)) self.view.checkBoxShowLegend.stateChanged.connect(self.toggleLegend) + + def displayCounter(self, index : int, state : int): + # toggle the display of the counter i and update the splitter + self.transceiverTab.shownCounters[index] = (state == QtCore.Qt.Checked) + self.transceiverTab.update_ImageSplitter() + + def setCounterCheckBox(self, index : int, check : bool): + self.checkBoxCounters[index].setChecked(check) + + def enableCounterCheckBox(self, index : int, enabled : bool): + is_transceiver = self.mainWindow.romode.value in [3, 4] + is_image = self.view.radioButtonImage.isChecked() + self.checkBoxCounters[index].setEnabled(enabled and is_transceiver and is_image) + + def enableallCounterCheckBox(self, enabled : bool): + for checkBox in self.checkBoxCounters: + checkBox.setEnabled(enabled) + def refresh(self): self.getZMQHWM() @@ -262,7 +312,11 @@ class PlotTab(QtWidgets.QWidget): updates UI views should be called after every change to cmin or cmax """ for plot in self.imagePlots: - plot.getHistogramWidget().item.setLevels(min=self.cmin, max=self.cmax) + if isinstance(plot, list): # hacky for now only transceiver image is a PlotSplitter + for p in plot: + p.getHistogramWidget().item.setLevels(min=self.cmin, max=self.cmax) + else: + plot.getHistogramWidget().item.setLevels(min=self.cmin, max=self.cmax) self.view.cminSpinBox.setValue(self.cmin) self.view.cmaxSpinBox.setValue(self.cmax) @@ -271,7 +325,9 @@ class PlotTab(QtWidgets.QWidget): # print(f'color map:{self.comboBoxColorMap.currentText()}') self.mainWindow.plotAnalogImage.setColorMap(cm) self.mainWindow.plotDigitalImage.setColorMap(cm) - self.mainWindow.plotTransceiverImage.setColorMap(cm) + for i, showncounter in enumerate(self.transceiverTab.shownCounters): + if showncounter: + self.transceiverTab.transceiverImageViews[i].setColorMap(cm) def getZMQHWM(self): @@ -343,11 +399,11 @@ class PlotTab(QtWidgets.QWidget): self.mainWindow.transceiverPlots[i].hide() def addAllSelectedTransceiverPlots(self): - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): self.addSelectedTransceiverPlots(i) def removeAllTransceiverPlots(self): - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): self.mainWindow.transceiverPlots[i].hide() def showPlot(self): @@ -356,7 +412,7 @@ class PlotTab(QtWidgets.QWidget): self.mainWindow.plotTransceiverWaveform.hide() self.mainWindow.plotAnalogImage.hide() self.mainWindow.plotDigitalImage.hide() - self.mainWindow.plotTransceiverImage.hide() + self.transceiverTab.transceiverImageSplitter.hide() self.view.labelDigitalWaveformOption.setDisabled(True) self.view.radioButtonOverlay.setDisabled(True) self.view.radioButtonStripe.setDisabled(True) @@ -379,7 +435,10 @@ class PlotTab(QtWidgets.QWidget): if self.view.radioButtonWaveform.isChecked(): self.mainWindow.plotTransceiverWaveform.show() elif self.view.radioButtonImage.isChecked(): - self.mainWindow.plotTransceiverImage.show() + for i, showncounter in enumerate(self.transceiverTab.shownCounters): + self.transceiverTab.transceiverImageViews[i].setVisible(showncounter) + + self.transceiverTab.transceiverImageSplitter.show() def plotOptions(self): @@ -404,14 +463,18 @@ class PlotTab(QtWidgets.QWidget): 'bottom', "Transceiver Sample [#]") self.view.stackedWidgetPlotType.setCurrentIndex(0) + self.enableallCounterCheckBox(False) # disable counter checkboxes for waveform elif self.view.radioButtonImage.isChecked(): self.view.stackedWidgetPlotType.setCurrentIndex(2) + is_transceiver = self.mainWindow.romode.value in [3, 4] + self.enableallCounterCheckBox(is_transceiver) # enable counter checkboxes for matterhorn self.setDecoder() if self.view.radioButtonNoPlot.isChecked(): self.view.labelPlotOptions.hide() self.view.stackedWidgetPlotType.hide() + self.enableallCounterCheckBox(False) # disable counter checkboxes when no plot is selected # enable plotting else: self.view.labelPlotOptions.show() @@ -419,45 +482,57 @@ class PlotTab(QtWidgets.QWidget): self.mainWindow.read_timer.start(Defines.Time_Plot_Refresh_ms) def setDecoder(self): + # TODO: really dont like to set attributes on the fly - hard to understand whats going on if self.view.comboBoxPlot.currentText() == "Matterhorn02": print("Initializing decoder for Matterhorn02") - self.mainWindow.nTransceiverRows = Matterhorn02.nRows - self.mainWindow.nTransceiverCols = Matterhorn02.nCols + self.transceiverTab.nTransceiverRows = Matterhorn02.nRows + self.transceiverTab.nTransceiverCols = Matterhorn02.nCols + self.transceiverTab.update_numCounters(1) self.mainWindow.decoder = transform.Matterhorn02TransceiverTransform() elif self.view.comboBoxPlot.currentText() == "Matterhorn1_16bit_1_counter": print("Initializing decoder for Matterhorn1 with 1 counter 16 bit dynamic range") - self.mainWindow.nTransceiverRows = Matterhorn10.nRows - self.mainWindow.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.nTransceiverRows = Matterhorn10.nRows + self.transceiverTab.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.update_numCounters(1) self.mainWindow.decoder = transform.Matterhorn10Transform(16, 1) elif self.view.comboBoxPlot.currentText() == "Matterhorn1_16bit_4_counters": print("Initializing decoder for Matterhorn1 with 4 counters 16 bit dynamic range") - self.mainWindow.nTransceiverRows = Matterhorn10.nRows*4 - self.mainWindow.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.nTransceiverRows = Matterhorn10.nRows + self.transceiverTab.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.update_numCounters(4) self.mainWindow.decoder = transform.Matterhorn10Transform(16, 4) elif self.view.comboBoxPlot.currentText() == "Matterhorn1_8bit_1_counter": print("Initializing decoder for Matterhorn1 with 1 counter 8 bit dynamic range") - self.mainWindow.nTransceiverRows = Matterhorn10.nRows - self.mainWindow.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.nTransceiverRows = Matterhorn10.nRows + self.transceiverTab.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.update_numCounters(1) self.mainWindow.decoder = transform.Matterhorn10Transform(8, 1) elif self.view.comboBoxPlot.currentText() == "Matterhorn1_8bit_4_counters": print("Initializing decoder for Matterhorn1 with 4 counters 8 bit dynamic range") - self.mainWindow.nTransceiverRows = Matterhorn10.nRows*4 - self.mainWindow.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.nTransceiverRows = Matterhorn10.nRows + self.transceiverTab.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.update_numCounters(4) self.mainWindow.decoder = transform.Matterhorn10Transform(8, 4) elif self.view.comboBoxPlot.currentText() == "Matterhorn1_4bit_4_counters": print("Initializing decoder for Matterhorn1 with 4 counters 4 bit dynamic range") - self.mainWindow.nTransceiverRows = Matterhorn10.nRows*4 - self.mainWindow.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.nTransceiverRows = Matterhorn10.nRows + self.transceiverTab.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.update_numCounters(4) self.mainWindow.decoder = transform.Matterhorn10Transform(4, 4) elif self.view.comboBoxPlot.currentText() == "Matterhorn1_4bit_1_counter": print("Initializing decoder for Matterhorn1 with 1 counter 4 bit dynamic range") - self.mainWindow.nTransceiverRows = Matterhorn10.nRows - self.mainWindow.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.nTransceiverRows = Matterhorn10.nRows + self.transceiverTab.nTransceiverCols = Matterhorn10.nCols + self.transceiverTab.update_numCounters(1) self.mainWindow.decoder = transform.Matterhorn10Transform(4, 1) elif self.view.comboBoxPlot.currentText() == "Moench04": self.mainWindow.nAnalogRows = Moench04.nRows self.mainWindow.nAnalogCols = Moench04.nCols self.mainWindow.decoder = transform.Moench04AnalogTransform() + elif self.view.comboBoxPlot.currentText() == "Moench05": + self.mainWindow.nAnalogRows = Moench05.nRows + self.mainWindow.nAnalogCols = Moench05.nCols + self.mainWindow.decoder = transform.Moench05Transform() try: if hasattr(self.mainWindow.decoder, "compatibility") and callable(getattr(self.mainWindow.decoder, "compatibility")): @@ -533,21 +608,13 @@ class PlotTab(QtWidgets.QWidget): # get the RGB Values # print(color.getRgb()) - def showPlotValues(self, sender, pos): + def showPlotValues(self, sender, get_nMaxX, get_nMaxY, get_frame, pos): x = sender.getImageItem().mapFromScene(pos).x() y = sender.getImageItem().mapFromScene(pos).y() val = 0 - nMaxY = self.mainWindow.nAnalogRows - nMaxX = self.mainWindow.nAnalogCols - frame = self.mainWindow.analog_frame - if sender == self.mainWindow.plotDigitalImage: - nMaxY = self.mainWindow.nDigitalRows - nMaxX = self.mainWindow.nDigitalCols - frame = self.mainWindow.digital_frame - elif sender == self.mainWindow.plotTransceiverImage: - nMaxY = self.mainWindow.nTransceiverRows - nMaxX = self.mainWindow.nTransceiverCols - frame = self.mainWindow.transceiver_frame + nMaxX = get_nMaxX() + nMaxY = get_nMaxY() + frame = get_frame() if 0 <= x < nMaxX and 0 <= y < nMaxY and not np.array_equal(frame, []): val = frame[int(y), int(x)] message = f'[row, col]: [{y:.2f}, {x:.2f}] = {val:.2f}' diff --git a/pyctbgui/pyctbgui/services/Transceiver.py b/pyctbgui/pyctbgui/services/Transceiver.py index 13bb72fca..828decd26 100644 --- a/pyctbgui/pyctbgui/services/Transceiver.py +++ b/pyctbgui/pyctbgui/services/Transceiver.py @@ -2,7 +2,7 @@ from functools import partial from pathlib import Path import numpy as np -from PyQt5 import QtWidgets, uic +from PyQt5 import QtWidgets, QtCore, uic import pyqtgraph as pg from pyqtgraph import LegendItem @@ -24,11 +24,18 @@ class TransceiverTab(QtWidgets.QWidget): self.plotTab = None self.legend: LegendItem | None = None self.acquisitionTab = None - + self.nCounters: int = Defines.transceiver.maxcount + self.nTransceiverRows : int = 0 + self.nTransceiverCols : int = 0 + self.shownCounters: list[bool] = [True] * Defines.transceiver.maxcount # per default show all 4 counters + self.transceiverImageSplitter = QtWidgets.QSplitter(QtCore.Qt.Vertical) + self.transceiverImageViews : list = [] # pg image view for each counter + self.firstTransceiverImage : list[bool] = [True] * Defines.transceiver.maxcount # to keep track of first image for each counter to maintain zoom state + def setup_ui(self): self.plotTab = self.mainWindow.plotTab self.acquisitionTab = self.mainWindow.acquisitionTab - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): self.setTransceiverButtonColor(i, self.plotTab.getRandomColor()) self.initializeAllTransceiverPlots() @@ -39,7 +46,7 @@ class TransceiverTab(QtWidgets.QWidget): self.plotTab.subscribeToggleLegend(self.updateLegend) def connect_ui(self): - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): getattr(self.view, f"checkBoxTransceiver{i}").stateChanged.connect(partial(self.setTransceiverEnable, i)) getattr(self.view, f"checkBoxTransceiver{i}Plot").stateChanged.connect(partial(self.setTransceiverEnablePlot, i)) @@ -55,7 +62,7 @@ class TransceiverTab(QtWidgets.QWidget): """ enabledPlots = [] self.legend.clear() - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): if getattr(self.view, f'checkBoxTransceiver{i}Plot').isChecked(): plotName = getattr(self.view, f"labelTransceiver{i}").text() enabledPlots.append((self.mainWindow.transceiverPlots[i], plotName)) @@ -104,7 +111,7 @@ class TransceiverTab(QtWidgets.QWidget): trans_array = self._processWaveformData(data, dSamples, self.mainWindow.romode.value, self.mainWindow.nDBitEnabled, self.nTransceiverEnabled) idx = 0 - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): checkBoxPlot = getattr(self.view, f"checkBoxTransceiver{i}Plot") checkBoxEn = getattr(self.view, f"checkBoxTransceiver{i}") if checkBoxEn.isChecked() and checkBoxPlot.isChecked(): @@ -133,9 +140,7 @@ class TransceiverTab(QtWidgets.QWidget): transceiverOffset += nDBitEnabled * (nbitsPerDBit // 8) trans_array = np.array(np.frombuffer(data, offset=transceiverOffset, dtype=np.uint8)) - tmp = self.mainWindow.decoder(trans_array) - - return tmp + return self.mainWindow.decoder(trans_array) def processImageData(self, data, dSamples): """ @@ -145,28 +150,47 @@ class TransceiverTab(QtWidgets.QWidget): data: raw image data """ # get zoom state - viewBox = self.mainWindow.plotTransceiverImage.getView() - - state = viewBox.getState() + image_states = [image_view.getView().getState() for image_view in self.transceiverImageViews] + + transceiver_frame : np.ndarray = None try: - self.mainWindow.transceiver_frame = self._processImageData(data, dSamples, self.mainWindow.romode.value, + transceiver_frame = self._processImageData(data, dSamples, self.mainWindow.romode.value, self.mainWindow.nDBitEnabled) self.plotTab.ignoreHistogramSignal = True - self.mainWindow.plotTransceiverImage.setImage(self.mainWindow.transceiver_frame) + + for i in range(transceiver_frame.shape[0]): + self.transceiverImageViews[i].setImage(transceiver_frame[i]) except Exception as e: self.mainWindow.statusbar.setStyleSheet("color:red") self.acquisitionTab.updateCurrentFrame('Invalid Image') self.mainWindow.statusbar.showMessage(str(e)) print("Error: ", str(e)) - self.plotTab.setFrameLimits(self.mainWindow.transceiver_frame) + self.plotTab.setFrameLimits(transceiver_frame) # keep the zoomed in state (not 1st image) - if self.mainWindow.firstTransceiverImage: - self.mainWindow.firstTransceiverImage = False - else: - viewBox.setState(state) - return self.mainWindow.transceiver_frame + for idx, image_view in enumerate(self.transceiverImageViews): + if(self.firstTransceiverImage[idx] and self.shownCounters[idx]): + self.firstTransceiverImage[idx] = False + else: + image_view.getView().setState(image_states[idx]) + + return transceiver_frame + + def update_numCounters(self, num_counters): + # update the number of counters and adjust the image splitter accordingly + self.nCounters = num_counters + for i in range(Defines.transceiver.maxcount): + self.shownCounters[i] = i < self.nCounters + self.plotTab.setCounterCheckBox(i, self.shownCounters[i]) # check the counter checkbox + self.plotTab.enableCounterCheckBox(i, self.shownCounters[i]) # disable counter checkbox + + self.update_ImageSplitter() # update the splitter to show/hide image views based on the number of counters + + + def update_ImageSplitter(self): + for i, showncounter in enumerate(self.shownCounters): + self.transceiverImageViews[i].setVisible(showncounter) def initializeAllTransceiverPlots(self): self.mainWindow.plotTransceiverWaveform = pg.plot() @@ -174,7 +198,7 @@ class TransceiverTab(QtWidgets.QWidget): self.mainWindow.verticalLayoutPlot.addWidget(self.mainWindow.plotTransceiverWaveform, 5) self.mainWindow.transceiverPlots = {} waveform = np.zeros(1000) - for i in range(Defines.transceiver.count): + for i in range(Defines.transceiver.maxcount): pen = pg.mkPen(color=self.getTransceiverButtonColor(i), width=1) legendName = getattr(self.view, f"labelTransceiver{i}").text() self.mainWindow.transceiverPlots[i] = self.mainWindow.plotTransceiverWaveform.plot(waveform, @@ -182,16 +206,19 @@ class TransceiverTab(QtWidgets.QWidget): name=legendName) self.mainWindow.transceiverPlots[i].hide() - self.mainWindow.plotTransceiverImage = pg.ImageView() - self.mainWindow.nTransceiverRows = 0 - self.mainWindow.nTransceiverCols = 0 - self.mainWindow.transceiver_frame = np.zeros( - (self.mainWindow.nTransceiverRows, self.mainWindow.nTransceiverCols)) - self.mainWindow.plotTransceiverImage.setImage(self.mainWindow.transceiver_frame) - self.mainWindow.verticalLayoutPlot.addWidget(self.mainWindow.plotTransceiverImage, 6) - + # initialize image cm = pg.colormap.get('CET-L9') # prepare a linear color map - self.mainWindow.plotTransceiverImage.setColorMap(cm) + + for i in range(self.nCounters): + imageView = pg.ImageView() + imageView.setColorMap(cm) + self.transceiverImageViews.append(imageView) + self.transceiverImageSplitter.addWidget(imageView) + + self.update_ImageSplitter() # update the splitter + self.mainWindow.verticalLayoutPlot.addWidget(self.transceiverImageSplitter, 6) + + def getTransceiverEnableReg(self): retval = self.det.transceiverenable diff --git a/pyctbgui/pyctbgui/ui/plot.ui b/pyctbgui/pyctbgui/ui/plot.ui index 848d48f16..01d2b5ec1 100644 --- a/pyctbgui/pyctbgui/ui/plot.ui +++ b/pyctbgui/pyctbgui/ui/plot.ui @@ -6,8 +6,8 @@ 0 0 - 860 - 800 + 1937 + 1104 @@ -25,7 +25,7 @@ 10 50 841 - 141 + 161 @@ -35,13 +35,10 @@ QFrame::Raised - - - - true - + + - Type: + Options: @@ -50,6 +47,12 @@ false + + + 0 + 31 + + Distribution @@ -58,28 +61,193 @@ - - - - Qt::Vertical + + + + true - + - 20 - 40 + 0 + 31 - + + Waveform + + + true + + + buttonGroup + + + + + + + + 0 + 31 + + + + Counter 2 + + + + + + + + 0 + 31 + + + + Counter 3 + + + + + + + true + + + + 0 + 31 + + + + No Plot + + + false + + + buttonGroup + + + + + + + + 0 + 31 + + + + Counter 0 + + + + + + + true + + + + 0 + 31 + + + + <html><head/><body><p>If set to high readout, zmq HWM is set to 2 and buffer size to 1MB to drop zmq packets to catch up.</p><p>If set to low readout (default), zmq HWM is set to zmq default (1000) and buffer size to os default to not drop any zmq packets.</p></body></html> + + + + Low - drop no zmq packet + + + + + High - drop zmq packets to catch up + + + + + + + + true + + + + 0 + 31 + + + + Type: + + + + + + + + 150 + 16777215 + + + + <html><head/><body><p>If set to high readout, zmq HWM is set to 2 and buffer size to 1MB to drop zmq packets to catch up.</p><p>If set to low readout (default), zmq HWM is set to zmq default (1000) and buffer size to os default to not drop any zmq packets.</p></body></html> + + + Readout speed: + + + + + + + true + + + + 0 + 31 + + + + Image + + + buttonGroup + + + + + 16777215 + 31 + + - 2 + 0 + + 0 + + + 0 + + + + 0 + 31 + + Digital plot: @@ -87,6 +255,12 @@ + + + 0 + 31 + + Overlay @@ -110,6 +284,12 @@ + + + 0 + 31 + + show legend @@ -120,6 +300,12 @@ + + + 0 + 31 + + Stripe @@ -149,6 +335,42 @@ + + 0 + + + 0 + + + + + Decoder: + + + + + + + Color Map: + + + + + + + true + + + + 120 + 31 + + + + Color map of the image + + + @@ -202,6 +424,11 @@ Moench04 + + + + Moench05 + @@ -210,35 +437,6 @@ - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - true - - - - 120 - 31 - - - - Color map of the image - - - @@ -255,292 +453,661 @@ - - - - Decoder: + + + + Qt::Horizontal - - - - - - Color Map: + + + 40 + 20 + - + - - + + + + + 0 + 31 + + - Options: + Counter 1 - - - - true - - - No Plot - - - false - - - buttonGroup - - - - - - - true - + + 0 31 - - <html><head/><body><p>If set to high readout, zmq HWM is set to 2 and buffer size to 1MB to drop zmq packets to catch up.</p><p>If set to low readout (default), zmq HWM is set to zmq default (1000) and buffer size to os default to not drop any zmq packets.</p></body></html> - - - - Low - drop no zmq packet - - - - - High - drop zmq packets to catch up - - - - - - <html><head/><body><p>If set to high readout, zmq HWM is set to 2 and buffer size to 1MB to drop zmq packets to catch up.</p><p>If set to low readout (default), zmq HWM is set to zmq default (1000) and buffer size to os default to not drop any zmq packets.</p></body></html> - Readout speed: + Counters: - - - - true - - - Image - - - buttonGroup - - - - - - - true - - - Waveform - - - true - - - buttonGroup - - - - 0 - 480 + 10 + 440 841 - 311 + 400 + + + 0 + 400 + + + + + 16777215 + 16777215 + + QFrame::StyledPanel QFrame::Sunken - - - + + + false + + + 0 + 31 + + + + + 16777215 + 16777215 + + Fit Panel ADC: - - + + false - - Max: + + + 0 + 31 + - - - - - - false + + + 16777215 + 16777215 + - - Values - - - - - - - false + + QFrame::NoFrame Dynamic Range: - - + + false + + + 0 + 31 + + + + + 16777215 + 16777215 + + - Y: + Serial Offset: - - + + false + + + 100 + 31 + + + + + 45 + 16777215 + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - + + false + + + 100 + 31 + + + + + 16777215 + 16777215 + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - + + false + + + 0 + 0 + + + + + 16777215 + 16777215 + + Min: - - + + false + + + 245 + 31 + + + + + 200 + 16777215 + + - X: + Pedestal Subtract - + false + + + 100 + 31 + + + + + 45 + 16777215 + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - + + false - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 0 + 31 + + + + Raw Data - - + + false - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + 0 + 31 + + + + + 16777215 + 16777215 + + + + Min: - + + + + false + + + + 0 + 31 + + + + + 16777215 + 16777215 + + + + N Counters: + + + + + + + false + + + + 0 + 0 + + + + + 16777215 + 16777215 + + + + Max: + + + + false + + + 100 + 31 + + + + + 45 + 16777215 + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + false + + + 100 + 31 + + + + + 45 + 16777215 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + false + + + + 0 + 31 + + Image Pixels: - + + + + false + + + + 100 + 31 + + + + + 45 + 16777215 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + false + + + + 0 + 31 + + + + + 16777215 + 16777215 + + + + X: + + + + false + + + 100 + 31 + + + + + 16777215 + 16777215 + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - + + + + false + + + + 100 + 31 + + + + + 16777215 + 16777215 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + + false + + + + 100 + 31 + + + + + 45 + 16777215 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + false + + + 100 + 31 + + + + + 45 + 16777215 + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - + + + + false + + + + 0 + 0 + + + + + 16777215 + 16777215 + + + + Plot Bit: + + + + + + + false + + + + 115 + 0 + + + + + 156 + 16777215 + + + + Max: + + + + + + + false + + + + 0 + 31 + + + + + 16777215 + 31 + + + + Y: + + + + + + + false + + + + 100 + 31 + + + + + 45 + 16777215 + + + + Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter + + + + + + + false + + + X + + + + + false @@ -549,77 +1116,17 @@ - - + + false - Min: + Values - - - - false - - - X - - - - - - - false - - - Max: - - - - - - - false - - - Serial offset: - - - - - - - false - - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - - - - - - false - - - Plot Bit: - - - - - - - false - - - Raw Data - - - - + @@ -635,241 +1142,223 @@ - - - - false - - - Pedestal Subtract - - - - - - - false - - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - - - - - - false - - - Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter - - - - - - - false - - - N Counters: - - - 10 - 219 + 221 841 - 81 + 91 + + + 0 + 0 + + QFrame::StyledPanel QFrame::Raised - - - - 0 - -7 - 841 - 111 - + + + 9 - - - - - Qt::Horizontal - - - QSizePolicy::Fixed - - - - 40 - 20 - - - - - - - - Color Range: - - - - - - - - - 0 - 0 - 121 - 91 - - - - - - - - 16777215 - 15 - - - - All - - - true - - - buttonGroup_4 - - - - - - - true - - - - 16777215 - 15 - - - - 3-97% - - - buttonGroup_4 - - - - - - - - 16777215 - 15 - - - - Fixed - - - buttonGroup_4 - - - - - - - - - - - - 50 - 16777215 - - - - min: - - - - - - - false - - - -1000.000000000000000 - - - 100000.000000000000000 - - - - - - - - 50 - 16777215 - - - - max: - - - - - - - false - - - 100000.000000000000000 - - - - - - - Qt::Horizontal - - - QSizePolicy::Fixed - - - - 40 - 20 - - - - - - + + 9 + + + + + QFrame::NoFrame + + + QFrame::Plain + + + + + + true + + + + 16777215 + 15 + + + + 3-97% + + + buttonGroup_4 + + + + + + + + 16777215 + 15 + + + + All + + + true + + + buttonGroup_4 + + + + + + + + 16777215 + 15 + + + + Fixed + + + buttonGroup_4 + + + + + + + + + + Qt::Horizontal + + + QSizePolicy::Fixed + + + + 40 + 20 + + + + + + + + + 0 + 31 + + + + + 16777215 + 31 + + + + Color Range: + + + + + + + false + + + + 0 + 31 + + + + -1000.000000000000000 + + + 100000.000000000000000 + + + + + + + + 50 + 31 + + + + max: + + + + + + + false + + + + 0 + 31 + + + + 100000.000000000000000 + + + + + + + + 50 + 31 + + + + min: + + + + + + + Qt::Horizontal + + + QSizePolicy::Fixed + + + + 40 + 20 + + + + + 10 - 330 + 322 841 - 101 + 108 @@ -878,208 +1367,183 @@ QFrame::Raised - - - - 0 - 0 - 841 - 51 - - - - - - - Qt::Horizontal - - - QSizePolicy::Fixed - - - - 40 - 20 - - - - - - - - true - - - Pedestal: - - - - - - - - 250 - 0 - - - - recorded frames: 0 - - - - - - - true - - - Record - - - true - - - false - - - buttonGroup_3 - - - - - - - true - - - Apply - - - true - - - buttonGroup_3 - - - - - - - true - - - - 0 - 31 - - - - background-color: rgb(199, 213, 207); - - - Reset - - - - - - - Qt::Horizontal - - - QSizePolicy::Fixed - - - - 40 - 20 - - - - - - - - - - -1 - 49 - 841 - 51 - - - - - - - Qt::Horizontal - - - - 40 - 20 - - - - - - - - - 120 - 31 - - - - background-color: rgb(199, 213, 207); - - - Load Pedestal - - - - - - - - 120 - 31 - - - - background-color: rgb(199, 213, 207); - - - Save Pedestal - - - - - - - Qt::Horizontal - - - QSizePolicy::Preferred - - - - 40 - 20 - - - - - - + + + + + true + + + + 16777215 + 31 + + + + Apply + + + true + + + buttonGroup_3 + + + + + + + true + + + + 16777215 + 31 + + + + Record + + + true + + + false + + + buttonGroup_3 + + + + + + + + 0 + 0 + + + + + 16777215 + 31 + + + + recorded frames: 0 + + + + + + + true + + + + 0 + 31 + + + + background-color: rgb(199, 213, 207); + + + Reset + + + + + + + true + + + + 150 + 0 + + + + + 16777215 + 31 + + + + Pedestal: + + + + + + + QFrame::NoFrame + + + QFrame::Raised + + + + + + + 120 + 31 + + + + background-color: rgb(199, 213, 207); + + + Save Pedestal + + + + + + + + 120 + 31 + + + + background-color: rgb(199, 213, 207); + + + Load Pedestal + + + + + + + Qt::Horizontal + + + QSizePolicy::Fixed + + + + 40 + 20 + + + + + + + + + - diff --git a/pyctbgui/pyctbgui/utils/defines.py b/pyctbgui/pyctbgui/utils/defines.py index 2226b5c33..b4ecfc04e 100644 --- a/pyctbgui/pyctbgui/utils/defines.py +++ b/pyctbgui/pyctbgui/utils/defines.py @@ -35,8 +35,8 @@ class Defines: loops_count = 6 class transceiver: - count = 4 - tabIndex = 4 + maxcount = 4 + maxtabIndex = 4 class slowAdc: tabIndex = 2 diff --git a/python/slsdet/detector.py b/python/slsdet/detector.py index a984fedd5..211ddc602 100755 --- a/python/slsdet/detector.py +++ b/python/slsdet/detector.py @@ -622,7 +622,7 @@ class Detector(CppDetectorApi): >>> d.exptime = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.exptime = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds @@ -674,7 +674,7 @@ class Detector(CppDetectorApi): >>> d.period = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.period = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds @@ -740,7 +740,7 @@ class Detector(CppDetectorApi): >>> d.delay = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.delay = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds @@ -2429,19 +2429,63 @@ class Detector(CppDetectorApi): """ @property - def datastream(self): + def udp_datastream(self): """ - datastream [left|right] [0, 1] - [Eiger] Enables or disables data streaming from left or/and right side of detector for 10GbE mode. 1 (enabled) by default. + Get or set UDP data streaming for detector/receiver ports. + + [Eiger]: LEFT, RIGHT - 10GbE UDP ports of the detector. + [Jungfrau][Moench]: TOP, BOTTOM - UDP ports of the receiver + (only when numinterfaces is set to 2). + + :getter: Returns a dictionary containing the UDP data stream enable state + for all available ports. When multiple detector modules are present, + identical values are returned as a single boolean. If different + values are found, a list of booleans is returned. + + :setter: Takes a tuple of ``(portPosition, bool)`` to set the UDP data + stream state for a single port. + + Enum: portPosition + + Example + ------- + Get UDP streaming state for all ports: + + >>> d.udp_datastream + {: False, : True} + + Multiple detectors with identical states: + + >>> d.udp_datastream + {: False, : True} + + Multiple detectors with different states: + + >>> d.udp_datastream + {: [False, True], : [True, True]} + + Enable UDP streaming for a specific port: + + >>> from slsdet import portPosition + >>> d.udp_datastream = (portPosition.TOP, True) + + Disable UDP streaming for a specific port: + + >>> d.udp_datastream = (portPosition.BOTTOM, False) """ result = {} - for port in [defs.LEFT, defs.RIGHT]: - result[port] = element_if_equal(self.getDataStream(port)) + if self.type in [detectorType.JUNGFRAU, detectorType.MOENCH]: + ports = [defs.TOP, defs.BOTTOM] + else: + ports = [defs.LEFT, defs.RIGHT] + + for port in ports: + result[port] = element_if_equal(self.getUDPDataStream(port)) return result - @datastream.setter - def datastream(self, value): - ut.set_using_dict(self.setDataStream, *value) + @udp_datastream.setter + def udp_datastream(self, value): + self.setUDPDataStream(*value) @property @element @@ -2473,7 +2517,7 @@ class Detector(CppDetectorApi): >>> d.subexptime = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.subexptime = timedelta(seconds = 1.23, microseconds = 203) >>> >>> # using DurationWrapper to set in seconds @@ -2539,7 +2583,7 @@ class Detector(CppDetectorApi): >>> d.subdeadtime = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.subdeadtime = timedelta(seconds = 1.23, microseconds = 203) >>> >>> # using DurationWrapper to set in seconds @@ -2736,7 +2780,7 @@ class Detector(CppDetectorApi): >>> d.compdisabletime = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.compdisabletime = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds @@ -2829,7 +2873,7 @@ class Detector(CppDetectorApi): >>> d.storagecell_delay = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.storagecell_delay = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds @@ -3175,7 +3219,7 @@ class Detector(CppDetectorApi): >>> d.burstperiod = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.burstperiod = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds @@ -3335,7 +3379,7 @@ class Detector(CppDetectorApi): >>> d.gatedelay = 5e-07 >>> >>> # using timedelta (up to microseconds precision) - >>> from datatime import timedelta + >>> from datetime import timedelta >>> d.gatedelay = timedelta(seconds = 1, microseconds = 3) >>> >>> # using DurationWrapper to set in seconds diff --git a/python/src/detector.cpp b/python/src/detector.cpp index 482976edc..647b77974 100644 --- a/python/src/detector.cpp +++ b/python/src/detector.cpp @@ -653,9 +653,9 @@ void init_det(py::module &m) { Detector::getNumberofUDPInterfaces, py::arg() = Positions{}); CppDetectorApi.def("setNumberofUDPInterfaces", - (void (Detector::*)(int, sls::Positions)) & + (void (Detector::*)(int)) & Detector::setNumberofUDPInterfaces, - py::arg(), py::arg() = Positions{}); + py::arg()); CppDetectorApi.def("getSelectedUDPInterface", (Result(Detector::*)(sls::Positions) const) & Detector::getSelectedUDPInterface, @@ -841,6 +841,22 @@ void init_det(py::module &m) { CppDetectorApi.def( "setTransmissionDelay", (void (Detector::*)(int)) & Detector::setTransmissionDelay, py::arg()); + CppDetectorApi.def("getUDPDataStream", + (Result(Detector::*)(const defs::portPosition, + sls::Positions) const) & + Detector::getUDPDataStream, + py::arg(), py::arg() = Positions{}); + CppDetectorApi.def("setUDPDataStream", + (void (Detector::*)(const defs::portPosition, const bool, + sls::Positions)) & + Detector::setUDPDataStream, + py::arg(), py::arg(), py::arg() = Positions{}); + CppDetectorApi.def("getRxDisabledUDPPortIndices", + (std::vector(Detector::*)() const) & + Detector::getRxDisabledUDPPortIndices); + CppDetectorApi.def("getPortPositionList", + (std::vector(Detector::*)() const) & + Detector::getPortPositionList); CppDetectorApi.def("getUseReceiverFlag", (Result(Detector::*)(sls::Positions) const) & Detector::getUseReceiverFlag, @@ -1174,16 +1190,6 @@ void init_det(py::module &m) { CppDetectorApi.def("setQuad", (void (Detector::*)(const bool)) & Detector::setQuad, py::arg()); - CppDetectorApi.def("getDataStream", - (Result(Detector::*)(const defs::portPosition, - sls::Positions) const) & - Detector::getDataStream, - py::arg(), py::arg() = Positions{}); - CppDetectorApi.def("setDataStream", - (void (Detector::*)(const defs::portPosition, const bool, - sls::Positions)) & - Detector::setDataStream, - py::arg(), py::arg(), py::arg() = Positions{}); CppDetectorApi.def("getTop", (Result(Detector::*)(sls::Positions) const) & Detector::getTop, diff --git a/python/tests/test_det_api.py b/python/tests/test_det_api.py index 5c8cef0bc..cdda5b02c 100644 --- a/python/tests/test_det_api.py +++ b/python/tests/test_det_api.py @@ -11,9 +11,8 @@ from utils_for_test import ( LogLevel, ) from slsdet import Detector - from slsdet._slsdet import slsDetectorDefs - +from slsdet.utils import all_equal, element_if_equal detectorType = slsDetectorDefs.detectorType @@ -919,4 +918,89 @@ def test_type(session_simulator): def test_numinterfaces(session_simulator): d = Detector() - assert d.numinterfaces == 1 \ No newline at end of file + assert d.numinterfaces == 1 + + +@pytest.mark.detectorintegration +def test_udp_datastream(session_simulator, request): + """ Test using udp_datastream for eiger, jungfrau and moench.""" + det_type, num_interfaces, num_mods, d = session_simulator + assert d is not None + + from slsdet import portPosition + + if det_type in ['eiger']: + ports = [portPosition.LEFT, portPosition.RIGHT] + prev = [d.getUDPDataStream(i) for i in ports] + # ensure all equal for each value in prev + assert all_equal(prev) + prev_val = [element_if_equal(v) for v in prev] + + #list + with pytest.raises(Exception) as exc_info: + d.udp_datastream = (ports[0], [True, False]) + + # invalid port position + with pytest.raises(Exception) as exc_info: + d.udp_datastream = (portPosition.TOP, True) + + with pytest.raises(Exception) as exc_info: + d.udp_datastream = (portPosition.BOTTOM, True) + + # without port position + with pytest.raises(Exception) as exc_info: + d.udp_datastream = True + + d.udp_datastream = (ports[0], False) + assert d.udp_datastream[ports[0]] is False + d.udp_datastream = (ports[1], False) + assert d.udp_datastream[ports[1]] is False + d.udp_datastream = (ports[0], True) + assert d.udp_datastream[ports[0]] is True + d.udp_datastream = (ports[1], True) + assert d.udp_datastream[ports[1]] is True + + d.setUDPDataStream(ports[0], element_if_equal(prev[0])) + d.setUDPDataStream(ports[1], element_if_equal(prev[1])) + + elif det_type in ['jungfrau', 'moench'] and num_interfaces == 2: + ports = [portPosition.TOP, portPosition.BOTTOM] + prev = [d.getUDPDataStream(i) for i in ports] + # ensure all equal for each value in prev + assert all_equal(prev) + prev_val = [element_if_equal(v) for v in prev] + + #list + with pytest.raises(Exception) as exc_info: + d.udp_datastream = (ports[0], [True, False]) + + # invalid port position + with pytest.raises(Exception) as exc_info: + d.udp_datastream = (portPosition.LEFT, True) + + with pytest.raises(Exception) as exc_info: + d.udp_datastream = (portPosition.RIGHT, True) + + # without port position + with pytest.raises(Exception) as exc_info: + d.udp_datastream = True + + d.udp_datastream = (ports[0], False) + assert d.udp_datastream[ports[0]] is False + d.udp_datastream = (ports[1], False) + assert d.udp_datastream[ports[1]] is False + d.udp_datastream = (ports[0], True) + assert d.udp_datastream[ports[0]] is True + d.udp_datastream = (ports[1], True) + assert d.udp_datastream[ports[1]] is True + + d.setUDPDataStream(ports[0], element_if_equal(prev[0])) + d.setUDPDataStream(ports[1], element_if_equal(prev[1])) + + else: + with pytest.raises(Exception) as exc_info: + d.udp_datastream + + + + Log(LogLevel.INFOGREEN, f"✅ {request.node.name} passed") diff --git a/slsDetectorCalibration/moenchExecutables/CMakeLists.txt b/slsDetectorCalibration/moenchExecutables/CMakeLists.txt index 44b212df3..55faa558d 100644 --- a/slsDetectorCalibration/moenchExecutables/CMakeLists.txt +++ b/slsDetectorCalibration/moenchExecutables/CMakeLists.txt @@ -76,6 +76,14 @@ foreach(exe ${MOENCH_EXECUTABLES}) slsProjectOptions ) + target_compile_options(${exe} PRIVATE + -Wno-unused-but-set-variable + -Wno-format-nonliteral + -Wno-format-security + -Wno-double-promotion + -Wno-unused-variable + -Wno-format-overflow) + set_target_properties(${exe} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin diff --git a/slsDetectorCalibration/moenchExecutables/moench03Interpolation.cpp b/slsDetectorCalibration/moenchExecutables/moench03Interpolation.cpp index cbbe32746..dc3e71583 100644 --- a/slsDetectorCalibration/moenchExecutables/moench03Interpolation.cpp +++ b/slsDetectorCalibration/moenchExecutables/moench03Interpolation.cpp @@ -204,9 +204,9 @@ int main(int argc, char *argv[]) { */ //#endif - if (totquad > cmin && cl.x >= xmin && cl.x <= xmax && + if (totquad > static_cast(cmin) && cl.x >= xmin && cl.x <= xmax && cl.y >= ymin && cl.y <= ymax && - totquad < cmax) { + totquad < static_cast(cmax)) { // if (sum > cmin && totquad / sum > 0.8 && totquad / sum < 1.2 && // sum < cmax) { diff --git a/slsDetectorServers/eigerDetectorServer/9mhvserial_bf.c b/slsDetectorServers/eigerDetectorServer/9mhvserial_bf.c index f67a46dbf..8cd2c7c96 100644 --- a/slsDetectorServers/eigerDetectorServer/9mhvserial_bf.c +++ b/slsDetectorServers/eigerDetectorServer/9mhvserial_bf.c @@ -1,10 +1,10 @@ // SPDX-License-Identifier: LGPL-3.0-or-other // Copyright (C) 2021 Contributors to the SLS Detector Package +#include "clogger.h" #include "sls/ansi.h" #include -#include // File control definitions -#include // I2C_SLAVE, __u8 reg +#include // File control definitions #include #include // atoi #include // memset @@ -12,80 +12,102 @@ #include /* POSIX terminal control definitions */ #include // read, close -#define PORTNAME "/dev/ttyBF1" -#define GOODBYE 200 -#define BUFFERSIZE 16 -#define I2C_DEVICE_FILE "/dev/i2c-0" -#define I2C_DEVICE_ADDRESS 0x4C -// #define I2C_DEVICE_ADDRESS 0x48 -#define I2C_REGISTER_ADDRESS 0x40 +#define PORTNAME "/dev/ttyBF1" +#define GOODBYE 200 +#define BUFFERSIZE 16 +#define INFILE "/sys/devices/platform/i2c-bfin-twi.0/i2c-0/0-0048/in0_input" +#define OUTFILE "/sys/devices/platform/i2c-bfin-twi.0/i2c-0/0-0048/out0_output" +#define OUTENABLE \ + "/sys/devices/platform/i2c-bfin-twi.0/i2c-0/0-0048/out0_enable" -int i2c_open(const char *file, unsigned int addr) { - - // device file - int fd = open(file, O_RDWR); - if (fd < 0) { - LOG(logERROR, ("Warning: Unable to open file %s\n", file)); +int set_hv(int dac_value) { + if ((dac_value > 255) || (dac_value < 0)) { + LOG(logERROR, ("Invalid dac value %d\n", dac_value)); return -1; } - // device address - if (ioctl(fd, I2C_SLAVE, addr & 0x7F) < 0) { - LOG(logERROR, ("Warning: Unable to set slave address:0x%x \n", addr)); - return -2; - } - return fd; -} + dac_value = dac_value * 10; -int i2c_read() { - - int fd = i2c_open(I2C_DEVICE_FILE, I2C_DEVICE_ADDRESS); - __u8 reg = I2C_REGISTER_ADDRESS & 0xff; - - unsigned char buf = reg; - if (write(fd, &buf, 1) != 1) { - LOG(logERROR, - ("Warning: Unable to write read request to register %d\n", reg)); + FILE *file; + file = fopen(OUTFILE, "w"); + if (file == NULL) { + perror("set_hv:"); + LOG(logERROR, ("Cannot open out0_output file\n")); return -1; } - // read and update value (but old value read out) - if (read(fd, &buf, 1) != 1) { - LOG(logERROR, ("Warning: Unable to read register %d\n", reg)); - return -2; + if (setvbuf(file, NULL, _IONBF, 0) != 0) { + perror("set_hv:"); + LOG(logERROR, ("Cannot disable buffering\n")); + return -1; } - // read again to read the updated value - if (read(fd, &buf, 1) != 1) { - LOG(logERROR, ("Warning: Unable to read register %d\n", reg)); - return -2; + if (fprintf(file, "%d", dac_value) < 1) { + ferror(file); + LOG(logERROR, ("Couldn't write to out0_output file\n")); + return -1; } - close(fd); - return buf; -} - -int i2c_write(unsigned int value) { - - __u8 val = value & 0xff; - - int fd = i2c_open(I2C_DEVICE_FILE, I2C_DEVICE_ADDRESS); - if (fd < 0) - return fd; - - __u8 reg = I2C_REGISTER_ADDRESS & 0xff; - char buf[3]; - buf[0] = reg; - buf[1] = val; - if (write(fd, buf, 2) != 2) { - LOG(logERROR, - ("Warning: Unable to write %d to register %d\n", val, reg)); + if (fclose(file) != 0) { + perror("set_hv:"); + LOG(logERROR, ("Troubles closing out0_output file\n")); return -1; } - - close(fd); return 0; } +int enable_hv(int val) { + if ((val > 1) || (val < 0)) + return -1; + FILE *file; + file = fopen(OUTENABLE, "w"); + if (file == NULL) { + perror("enable_hv:"); + LOG(logERROR, ("Cannot open out0_enable file\n")); + return -1; + } + if (setvbuf(file, NULL, _IONBF, 0) != 0) { + perror("enable_hv:"); + LOG(logERROR, ("Cannot disable buffering\n")); + return -1; + } + if (fprintf(file, "%d", val) < 1) { + ferror(file); + LOG(logERROR, ("Couldn't write to out0_enable file\n")); + return -1; + } + if (fclose(file) != 0) { + perror("enable_hv:"); + LOG(logERROR, ("Troubles closing out0_enable file\n")); + return -1; + } + return 0; +} + +int get_hv() { + int value; + FILE *file; + file = fopen(INFILE, "r"); + if (file == NULL) { + perror("get_hv:"); + LOG(logERROR, ("Cannot open in0_input file\n")); + return -1; + } + if (fscanf(file, "%d", &value) < 1) { + ferror(file); + LOG(logERROR, ("Couldn't read from in0_input file\n")); + return -1; + } + if (fclose(file) != 0) { + perror("get_hv:"); + LOG(logERROR, ("Troubles closing out0_enable file\n")); + return -1; + } + return value / 10; +} + int main(int argc, char *argv[]) { + enable_hv(0); + set_hv(0); + int fd = open(PORTNAME, O_RDWR | O_NOCTTY | O_SYNC); if (fd < 0) { LOG(logERROR, ("Warning: Unable to open port %s\n", PORTNAME)); @@ -126,7 +148,7 @@ int main(int argc, char *argv[]) { int ival = 0; char buffer[BUFFERSIZE]; memset(buffer, 0, BUFFERSIZE); - buffer[BUFFERSIZE - 1] = '\n'; + // buffer[BUFFERSIZE - 1] = '\n'; LOG(logINFO, ("Ready...\n")); while (ret != GOODBYE) { @@ -149,35 +171,51 @@ int main(int argc, char *argv[]) { } // ok/ fail memset(buffer, 0, BUFFERSIZE); - buffer[BUFFERSIZE - 1] = '\n'; - if (i2c_write(ival) < 0) - strcpy(buffer, "fail "); + // buffer[BUFFERSIZE - 1] = '\n'; + + if (set_hv(ival) < 0) + strcpy(buffer, "fail\n"); + else if (enable_hv(ival > 0 ? 1 : 0) < 0) + strcpy(buffer, "fail\n"); else - strcpy(buffer, "success "); + strcpy(buffer, "success\n"); + /* + if (i2c_write(ival) < 0) + strcpy(buffer, "fail "); + else + strcpy(buffer, "success "); + */ LOG(logINFO, ("Sending: '%s'\n", buffer)); - n = write(fd, buffer, BUFFERSIZE); + n = write(fd, buffer, strlen(buffer)); // BUFFERSIZE); LOG(logDEBUG1, ("Sent %d Bytes\n", n)); break; case 'g': - ival = i2c_read(); - // ok/ fail - memset(buffer, 0, BUFFERSIZE); - buffer[BUFFERSIZE - 1] = '\n'; + ival = get_hv(); if (ival < 0) - strcpy(buffer, "fail "); + strcpy(buffer, "fail\n"); else - strcpy(buffer, "success "); - n = write(fd, buffer, BUFFERSIZE); + strcpy(buffer, "success\n"); + /* + ival = i2c_read(); + // ok/ fail + memset(buffer, 0, BUFFERSIZE); + buffer[BUFFERSIZE - 1] = '\n'; + if (ival < 0) + strcpy(buffer, "fail "); + else + strcpy(buffer, "success "); + */ + n = write(fd, buffer, strlen(buffer)); // BUFFERSIZE); LOG(logINFO, ("Sending: '%s'\n", buffer)); LOG(logDEBUG1, ("Sent %d Bytes\n", n)); // value memset(buffer, 0, BUFFERSIZE); - buffer[BUFFERSIZE - 1] = '\n'; + // buffer[BUFFERSIZE - 1] = '\n'; if (ival >= 0) { LOG(logINFO, ("Sending: '%d'\n", ival)); - sprintf(buffer, "%d ", ival); - n = write(fd, buffer, BUFFERSIZE); + sprintf(buffer, "%d\n", ival); + n = write(fd, buffer, strlen(buffer)); // BUFFERSIZE); LOG(logINFO, ("Sent %d Bytes\n", n)); } else LOG(logERROR, ("%s\n", buffer)); diff --git a/slsDetectorServers/eigerDetectorServer/Makefile b/slsDetectorServers/eigerDetectorServer/Makefile index f7f2be00a..950547c7d 100755 --- a/slsDetectorServers/eigerDetectorServer/Makefile +++ b/slsDetectorServers/eigerDetectorServer/Makefile @@ -41,9 +41,9 @@ $(PROGS): $(OBJS) hv9m_blackfin_server:9mhvserial_bf.c - $(BLACKFIN_CC) -o hv9m_blackfin_server 9mhvserial_bf.c -Wall #-DVERBOSE + $(BLACKFIN_CC) $(CFLAGS) -o hv9m_blackfin_server 9mhvserial_bf.c -Wall #-DVERBOSE mv hv9m_blackfin_server $(DESTDIR) - rm hv9m_blackfin_server.gdb $(main_src)*.o $(md5_dir)*.o + rm hv9m_blackfin_server.gdb clean: rm -rf $(DESTDIR)/$(PROGS) *.o $(DESTDIR)/hv9m_blackfin_server $(main_src)*.o $(md5_dir)*.o diff --git a/slsDetectorServers/matterhornServer/.gitattributes b/slsDetectorServers/matterhornServer/.gitattributes new file mode 100644 index 000000000..087a700fc --- /dev/null +++ b/slsDetectorServers/matterhornServer/.gitattributes @@ -0,0 +1,3 @@ +bin/ filter=lfs diff=lfs merge=lfs -text +bin/** filter=lfs diff=lfs merge=lfs -text +bin/matterhornDetectorServer filter=lfs diff=lfs merge=lfs -text diff --git a/slsDetectorServers/matterhornServer/CMakeLists.txt b/slsDetectorServers/matterhornServer/CMakeLists.txt index e4d237e41..34d539b08 100644 --- a/slsDetectorServers/matterhornServer/CMakeLists.txt +++ b/slsDetectorServers/matterhornServer/CMakeLists.txt @@ -2,22 +2,40 @@ set(MATTERHORN_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/MatterhornApp.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/communication/SPICommunication.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/HelperFunctions.cpp +) + +set(MATTERHORN_INCLUDE_DIRS + ${CMAKE_CURRENT_SOURCE_DIR}/src + ${CMAKE_CURRENT_SOURCE_DIR}/src/communication + ${CMAKE_CURRENT_SOURCE_DIR}/src/utils + ${CMAKE_CURRENT_SOURCE_DIR}/src/defs + ${CMAKE_CURRENT_SOURCE_DIR}/../../slsSupportLib/include + ${CMAKE_CURRENT_SOURCE_DIR}/../slsDetectorServer_cpp/include ) if(SLS_USE_SIMULATOR) - list(APPEND MATTERHORN_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/VirtualMatterhornServer.cpp) + set(MATTERHORN_SERVER_HEADER "VirtualMatterhornServer.hpp") add_executable(matterhornDetectorServer_virtual ${MATTERHORN_SOURCES}) + target_compile_definitions(matterhornDetectorServer_virtual PRIVATE + MATTERHORN_SERVER_HEADER= + MATTERHORN_SERVER_CLASS=VirtualMatterhornServer + ) + target_include_directories(matterhornDetectorServer_virtual - PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include - ${CMAKE_CURRENT_SOURCE_DIR}/../../slsSupportLib/include - ${CMAKE_CURRENT_SOURCE_DIR}/../slsDetectorServer_cpp/include) + PRIVATE ${MATTERHORN_INCLUDE_DIRS}) target_link_libraries(matterhornDetectorServer_virtual PUBLIC slsSupportStatic - slsServerStatic) + slsServerStatic + slsProjectOptions + PRIVATE + slsProjectWarnings + ) set_target_properties(matterhornDetectorServer_virtual PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin @@ -26,37 +44,61 @@ if(SLS_USE_SIMULATOR) install(TARGETS matterhornDetectorServer_virtual RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) -else() - list(APPEND MATTERHORN_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/MatterhornServer.cpp) +endif() # maybe better to have a else if build with simulators on one always uses the virtual server in MatterhornApp + +if(SLS_USE_MATTERHORN) + + + if(CMAKE_CROSSCOMPILING) # only update version if cross compiling binaries + find_package(Python3 REQUIRED COMPONENTS Interpreter REQUIRED) + add_custom_target(update_server_version ALL + COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/etc/updateAPIVersion.py APIMATTERHORN ${CMAKE_SOURCE_DIR}/slsDetectorServers/matterhornServer ${CMAKE_SOURCE_DIR}/slsDetectorServers/slsDetectorServer_cpp + WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} + COMMENT "Updating APIMATTERHORN version" + VERBATIM) + endif() add_executable(matterhornDetectorServer ${MATTERHORN_SOURCES}) + if(CMAKE_CROSSCOMPILING) # only update version if cross compiling binaries + add_dependencies(matterhornDetectorServer update_server_version) + endif() + + target_compile_definitions(matterhornDetectorServer PRIVATE + MATTERHORN_SERVER_HEADER= + MATTERHORN_SERVER_CLASS=MatterhornServer + ) + target_include_directories(matterhornDetectorServer - PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include - ${CMAKE_CURRENT_SOURCE_DIR}/../../slsSupportLib/include - ${CMAKE_CURRENT_SOURCE_DIR}/../slsDetectorServer_cpp/include) - + PRIVATE ${MATTERHORN_INCLUDE_DIRS}) + target_link_libraries(matterhornDetectorServer PUBLIC slsSupportStatic - #slsDetectorStatic - slsServerStatic) + slsServerStatic + slsProjectOptions + PRIVATE + slsProjectWarnings + ) + + if(CMAKE_CROSSCOMPILING) # change output directory to stay consitent with c server binaries when cross compiling + set(RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin) + else() + set(RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin) + endif() set_target_properties(matterhornDetectorServer PROPERTIES - RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin + RUNTIME_OUTPUT_DIRECTORY ${RUNTIME_OUTPUT_DIRECTORY} ) install(TARGETS matterhornDetectorServer RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} ) +endif() +if(SLS_USE_TESTS) + add_subdirectory(tests) endif() -#target_compile_definitions(matterhornDetectorServer_virtual -# PUBLIC VIRTUAL STOP_SERVER #what is this stop server should we really have a generic ServerAPP and pass compile options to create server e.g. MatterHorn? -#) - - - diff --git a/slsDetectorServers/matterhornServer/bin/matterhornDetectorServer b/slsDetectorServers/matterhornServer/bin/matterhornDetectorServer new file mode 100755 index 000000000..74a8fc366 --- /dev/null +++ b/slsDetectorServers/matterhornServer/bin/matterhornDetectorServer @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:4bfbe17a6b0efbdcd3da78eafb1ac6c212eb81434f36267640f75fe743dc0aea +size 316776 diff --git a/slsDetectorServers/matterhornServer/include/BaseMatterhornServer.h b/slsDetectorServers/matterhornServer/include/BaseMatterhornServer.h deleted file mode 100644 index 4ca5e46cc..000000000 --- a/slsDetectorServers/matterhornServer/include/BaseMatterhornServer.h +++ /dev/null @@ -1,113 +0,0 @@ -#pragma once -#include "DetectorServer.h" -#include "TCPInterface.h" -// #include "communication_funcs.h" -#include "fmt/format.h" -#include "sls/logger.h" -#include "sls/network_utils.h" -#include "sls/sls_detector_defs.h" -#include "sls/versionAPI.h" -#include -#include -#include -#include -#include -#include - -namespace sls { - -/// @brief Base class for Matterhorn Server, can be used to implement a virtual -/// server for testing and actual server -template -class BaseMatterhornServer - : public DetectorServer> { - - public: - /** - * Constructor - * Starts up a Matterhorn server. - * Assembles a Matterhorn server using TCP and UDP detector interfaces - * throws an exception in case of failure - * @param port TCP/IP port number - */ - explicit BaseMatterhornServer(uint16_t port = DEFAULT_TCP_CNTRL_PORTNO) - : DetectorServer>(port) {} - - ~BaseMatterhornServer() = default; - - ReturnCode get_version(ServerInterface &socket); - - ReturnCode get_detector_type(ServerInterface &socket); - - ReturnCode initial_checks(ServerInterface &socket); - - ReturnCode get_num_udp_interfaces(ServerInterface &socket) const; - - /** - * @brief call function corresponding to the function ID received from the - * client and send back the result - * @param function_id the function ID received from the client - * @param socket the socket to send the result back to the client - */ - ReturnCode processFunction(const detFuncs function_id, - ServerInterface &socket); - - private: - static std::string getMatterhornServerVersion(); - - static constexpr uint8_t numUDPInterfaces = - 1; // only one udp per module for now -}; - -template -ReturnCode -BaseMatterhornServer::processFunction(const detFuncs function_id, - ServerInterface &socket) { - - switch (function_id) { - default: - throw RuntimeError( - fmt::format("Function {} not implemented", - getFunctionNameFromEnum((enum detFuncs)function_id))); - } -} - -template -ReturnCode BaseMatterhornServer::get_num_udp_interfaces( - ServerInterface &socket) const { - return static_cast( - socket.sendResult(static_cast(numUDPInterfaces))); -} - -template -ReturnCode -BaseMatterhornServer::get_version(ServerInterface &socket) { - - auto version = getMatterhornServerVersion(); - char version_cstr[MAX_STR_LENGTH]{}; - strncpy(version_cstr, version.c_str(), version.size()); - LOG(TLogLevel::logDEBUG) << "Matterhorn Server Version: " << version; - return static_cast(socket.sendResult( - version_cstr)); // TODO: check what would be possible return codes!!! -} - -template -ReturnCode BaseMatterhornServer::get_detector_type( - ServerInterface &socket) { - int detectortype = slsDetectorDefs::detectorType::MATTERHORN; - return static_cast(socket.sendResult(detectortype)); -} - -template -std::string BaseMatterhornServer::getMatterhornServerVersion() { - return APIMATTERHORN; -} - -template -ReturnCode -BaseMatterhornServer::initial_checks(ServerInterface &socket) { - - return static_cast(this)->initial_checks(socket); -} - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/include/MatterhornServer.h b/slsDetectorServers/matterhornServer/include/MatterhornServer.h deleted file mode 100644 index 586818b71..000000000 --- a/slsDetectorServers/matterhornServer/include/MatterhornServer.h +++ /dev/null @@ -1,27 +0,0 @@ -#pragma once -#include "BaseMatterhornServer.h" -#include "TCPInterface.h" -#include "sls/sls_detector_defs.h" -#include -#include - -namespace sls { - -class MatterhornServer : public BaseMatterhornServer { - - public: - /** - * Constructor - * Starts up a Matterhorn server. - * Assembles a Matterhorn server using TCP and UDP detector interfaces - * throws an exception in case of failure - * @param port TCP/IP port number - */ - explicit MatterhornServer(uint16_t port = DEFAULT_TCP_CNTRL_PORTNO); - - ~MatterhornServer() = default; - - ReturnCode initial_checks(ServerInterface &socket); -}; - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/include/RegisterHelperStructs.hpp b/slsDetectorServers/matterhornServer/include/RegisterHelperStructs.hpp deleted file mode 100644 index 5f561a285..000000000 --- a/slsDetectorServers/matterhornServer/include/RegisterHelperStructs.hpp +++ /dev/null @@ -1,29 +0,0 @@ -#include -#include - -namespace sls { - -enum class IPCore : uint32_t; // forward declaration of IPCore enum class - -struct Register { - /// @brief IP core address space - const IPCore ip_core{}; // TODO replace by enum type - - /// @brief Offset of the register in bytes from the base address of the IP - /// core - const uint32_t offset_in_bytes{}; -}; - -struct RegisterField { - /// @brief Register to which the field belongs - const Register register_{}; - - /// @brief Bit position of the least significant bit of the field in the - /// register - const uint32_t bit_position{}; - - /// @brief Bitmask for the field - const uint32_t bitmask{}; -}; - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/include/VirtualMatterhornServer.h b/slsDetectorServers/matterhornServer/include/VirtualMatterhornServer.h deleted file mode 100644 index 61cb31bda..000000000 --- a/slsDetectorServers/matterhornServer/include/VirtualMatterhornServer.h +++ /dev/null @@ -1,24 +0,0 @@ - -#include "BaseMatterhornServer.h" - -namespace sls { - -class VirtualMatterhornServer - : public BaseMatterhornServer { - - public: - /** - * Constructor - * Starts up a virtual Matterhorn server. - * Assembles a virtual Matterhorn server using TCP and UDP detector - * interfaces throws an exception in case of failure - * @param port TCP/IP port number - */ - explicit VirtualMatterhornServer(uint16_t port = DEFAULT_TCP_CNTRL_PORTNO); - - ~VirtualMatterhornServer() = default; - - ReturnCode initial_checks(ServerInterface &socket); -}; - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/BaseMatterhornServer.hpp b/slsDetectorServers/matterhornServer/src/BaseMatterhornServer.hpp new file mode 100644 index 000000000..79d1c1883 --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/BaseMatterhornServer.hpp @@ -0,0 +1,116 @@ +#pragma once +#include "DetectorServer.hpp" +#include "TCPInterface.hpp" +#include "fmt/format.h" +#include "helpers/type_traits.hpp" +#include "sls/logger.h" +#include "sls/network_utils.h" +#include "sls/sls_detector_defs.h" +#include +#include +#include +#include +#include +#include + +namespace sls { + +/// @brief Base class for Matterhorn Server, can be used to implement a virtual +/// server for testing and actual server +template +class BaseMatterhornServer + : public DetectorServer> { + + public: + /** + * Constructor + * Starts up a Matterhorn server. + * Assembles a Matterhorn server using TCP and UDP detector interfaces + * throws an exception in case of failure + * @param port TCP/IP port number + */ + explicit BaseMatterhornServer( + std::unique_ptr< + DetectorServerImpl::value>> + impl, + uint16_t port = DEFAULT_TCP_CNTRL_PORTNO) + : DetectorServer>(std::move(impl), + port) {} + + ~BaseMatterhornServer() = default; + + ProcessedResult set_counter_mask(ServerInterface &socket); + + ProcessedResult get_counter_mask(ServerInterface &socket) const; + + /** + * @brief call function corresponding to the function ID received from the + * client and send back the result + * @param function_id the function ID received from the client + * @param socket the socket to send the result back to the client + */ + ProcessedResult processFunction(const detFuncs function_id, + ServerInterface &socket); + + private: + DerivedServer *getDerived() { return static_cast(this); } + + const DerivedServer *getDerived() const { + return static_cast(this); + } +}; + +template +ProcessedResult +BaseMatterhornServer::processFunction(const detFuncs function_id, + ServerInterface &socket) { + + switch (function_id) { + case detFuncs::F_SET_COUNTER_MASK: + return set_counter_mask(socket); + case detFuncs::F_GET_COUNTER_MASK: + return get_counter_mask(socket); + default: + throw RuntimeError( + fmt::format("Function {} not implemented", + getFunctionNameFromEnum((enum detFuncs)function_id))); + } +} + +template +ProcessedResult +BaseMatterhornServer::set_counter_mask(ServerInterface &socket) { + + uint32_t counter_mask{}; + try { + (void)socket.Receive(counter_mask); + } catch (const SocketError &e) { + LOG(logERROR) << "Failed to receive counter mask: " << e.what(); + return_fail("Failed to receive counter mask: " + std::string(e.what())); + } + + try { + this->getImpl()->set_counter_mask(counter_mask); + } catch (const std::exception &e) { + return_fail("Failed to set counter mask: " + std::string(e.what())); + } + + return send_ok(socket); +} + +template +ProcessedResult BaseMatterhornServer::get_counter_mask( + ServerInterface &socket) const { + + uint32_t counter_mask{}; + + try { + counter_mask = this->getImpl()->get_counter_mask(); + } catch (const std::exception &e) { + return_fail("Failed to get counter mask: " + std::string(e.what())); + } + + return send_result(socket, counter_mask); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/BaseMatterhornServerImpl.hpp b/slsDetectorServers/matterhornServer/src/BaseMatterhornServerImpl.hpp new file mode 100644 index 000000000..9d0e45d22 --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/BaseMatterhornServerImpl.hpp @@ -0,0 +1,358 @@ +#pragma once +#include "ArmBusCommunication.hpp" +#include "DetectorServerImpl.hpp" +#include "MemoryModel.hpp" +#include "communication/SPICommunication.hpp" +#include "defs/MatterhornDefs.hpp" +#include "defs/RegisterDefs.hpp" +#include "helpers/type_traits.hpp" +#include "sls/versionAPI.h" +#include "utils/HelperFunctions.hpp" +#include +#include + +namespace sls { + +template +class VirtualMatterhornServerImpl; // forward declare + +template +class BaseMatterhornServerImpl + : public DetectorServerImpl< + is_stop_server::value> { + public: + BaseMatterhornServerImpl(); + ~BaseMatterhornServerImpl() = default; + + // TODO: probably virtaul server specific details, can be moved to derived + // class + /// @brief initial setup of detector + void setupDetector(); + + /// @brief get matterhorn server version + std::string get_server_version() const; + + static uint8_t get_detector_type(); + + static uint8_t get_num_udp_interfaces(); + + uint64_t get_num_frames() const; + void set_num_frames(const uint64_t num_frames); + + uint32_t get_num_triggers() const; + void set_num_triggers(const uint32_t num_triggers); + + uint32_t get_counter_mask() const; + void set_counter_mask(const uint32_t counter_mask); + + void set_module_position(const size_t module_row, const size_t module_col, + const size_t module_index); + + slsDetectorDefs::rxParameters get_receiver_parameters() const; + + protected: + using MemoryModel = std::conditional_t< + std::is_same_v::value>>, + VirtualMemoryModel, + HardwareMemoryModel>; // 32 bit registers + + // TODO: for now in MatterhornServer and not generic Server but can be + // templated on different IPCore types for each detector + BusCommunication + busCommunication{}; + + using SPICommunicationClass = std::conditional_t< + std::is_same_v::value>>, + VirtualSPICommunication, + HardwareSPICommunication>; + + SPICommunicationClass spiCommunication{}; + + private: + static constexpr uint8_t numUDPInterfaces = + 1; // only one udp per module for now +}; + +template +BaseMatterhornServerImpl< + DerivedMatterhornServerImpl>::BaseMatterhornServerImpl() { + + // map the IP core base addresses to memory + busCommunication.mapToMemory(); // TODO: should this happen in constructor? + + // TODO: need to check if chip is attached + spiCommunication.open_spi(); // TODO: should this happen in constructor? +} + +template +void BaseMatterhornServerImpl::setupDetector() { + // TODO: extend + try { + // stop server does not talk to the board + if constexpr (!this->stop_server) { + set_num_frames(1); + set_num_triggers(1); + set_counter_mask(0xF); // enable counter all counters by default + } + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to setup detector: " << e.what(); + this->detectorSetupStatus.error_message = std::string(e.what()); + this->detectorSetupStatus.setup_status = + detector_setup_status::SETUP_STATUS::FAILED_SETUP; + } + + this->detectorSetupStatus.setup_status = + detector_setup_status::SETUP_STATUS::SUCCESSFUL_SETUP; +} + +template +std::string +BaseMatterhornServerImpl::get_server_version() + const { + + return APIMATTERHORN; +} + +template +uint8_t BaseMatterhornServerImpl< + DerivedMatterhornServerImpl>::get_num_udp_interfaces() { + return numUDPInterfaces; +} + +template +uint8_t +BaseMatterhornServerImpl::get_detector_type() { + return slsDetectorDefs::detectorType::MATTERHORN; +} + +template +uint64_t +BaseMatterhornServerImpl::get_num_frames() const { + + try { + uint32_t num_frames = + busCommunication.readRegister(Reg::MH_SM_Frames_Reg); + return static_cast(num_frames); + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to read number of frames from register: " + << e.what(); + throw; + } +} + +template +void BaseMatterhornServerImpl::set_num_frames( + const uint64_t num_frames) { + + try { + busCommunication.writeRegister(Reg::MH_SM_Frames_Reg, + static_cast(num_frames)); + auto written_num_frames = busCommunication.readRegister( + Reg::MH_SM_Frames_Reg); // check if write was successful + + if (num_frames != static_cast(written_num_frames)) { + throw std::runtime_error( + fmt::format("Requested {} frames, but set {}", num_frames, + static_cast(written_num_frames))); + } + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to set number of frames: " << e.what(); + throw; + } +} + +template +void BaseMatterhornServerImpl::set_num_triggers( + const uint32_t num_triggers) { + + try { + busCommunication.writeRegister(Reg::MH_SM_Triggers_Reg, num_triggers); + auto written_num_triggers = busCommunication.readRegister( + Reg::MH_SM_Triggers_Reg); // check if write was successful + if (num_triggers != written_num_triggers) { + throw std::runtime_error( + fmt::format("Requested {} triggers, but set {}", num_triggers, + written_num_triggers)); + } + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to set number of triggers: " << e.what(); + throw; + } +} + +template +uint32_t +BaseMatterhornServerImpl::get_num_triggers() + const { + + try { + uint32_t num_triggers = + busCommunication.readRegister(Reg::MH_SM_Triggers_Reg); + return num_triggers; + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to read number of triggers from register: " + << e.what(); + throw; + } +} + +template +void BaseMatterhornServerImpl::set_counter_mask( + const uint32_t counter_mask) { + + // counter mask update to num consecutive counters and starting_counter + uint32_t spi_counter_mask{}; + try { + spi_counter_mask = convertCounterMaskToSPICounterMask(counter_mask); + } catch (const std::invalid_argument &e) { + LOG(logERROR) << "Failed to convert counter mask to SPI counter mask: " + << e.what(); + + throw std::invalid_argument( + "Failed to convert counter mask to SPI counter mask: " + + std::string(e.what())); + } + + try { + auto reg_value = spiCommunication.SPIread( + SPIRegisters::NUM_COUNTERS.register_, + 0); // TODO: how to handle different chip ids -> e.g. broadcast do + // we want it to be configurable for different chip ids? - + // Command overload for some of the SPI registers + + setSPIRegisterField(reg_value, SPIRegisters::NUM_COUNTERS, + spi_counter_mask); + + spiCommunication.SPIwrite(SPIRegisters::NUM_COUNTERS.register_, 0, + reg_value); + } catch (const std::exception &e) { + throw RuntimeError("Failed to set counter mask: " + + std::string(e.what())); + } +} + +template +uint32_t +BaseMatterhornServerImpl::get_counter_mask() + const { + + std::vector reg_value{}; + try { + reg_value = spiCommunication.SPIread( + SPIRegisters::NUM_COUNTERS.register_, + 0); // TODO: how to handle different chip ids - + } catch (const std::exception &e) { + throw sls::RuntimeError( + "Failed to read counter mask from SPI register: " + + std::string(e.what())); + } + + // stores num_counters and starting_counter 0b0000 -> counter 0 enabled, + // 0b0001 -> counter 1 enabled, 0b0010 + uint32_t spi_counter_mask = + getSPIRegisterField(reg_value, SPIRegisters::NUM_COUNTERS); + + uint32_t actual_counter_mask = + convertSPICounterMaskToCounterMask(spi_counter_mask); + + return actual_counter_mask; +} + +template +void BaseMatterhornServerImpl::set_module_position( + const size_t module_row, const size_t module_col, + const size_t module_index) { + + // write to register + uint32_t register_value_LSB{}; + uint32_t register_value_MSB{}; + + try { + register_value_LSB = + busCommunication.readRegister(Reg::Frame_HDR_ModCoord_LSB_Reg); + register_value_MSB = + busCommunication.readRegister(Reg::Frame_HDR_ModCoord_MSB_Reg); + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to read module position register: " + << e.what(); + throw; + } + + try { + setRegisterField(register_value_LSB, Reg::ModuleRow, module_row); + setRegisterField(register_value_LSB, Reg::ModuleCol, module_col); + setRegisterField(register_value_MSB, Reg::ModuleCoordz, 0); + setRegisterField(register_value_MSB, Reg::ModuleIndex, module_index); + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to set module position register fields: " + << e.what(); + throw; + } + + try { + busCommunication.writeRegister(Reg::Frame_HDR_ModCoord_LSB_Reg, + register_value_LSB); + + auto written_register_value_LSB = busCommunication.readRegister( + Reg::Frame_HDR_ModCoord_LSB_Reg); // check if write was successful + + busCommunication.writeRegister(Reg::Frame_HDR_ModCoord_MSB_Reg, + register_value_MSB); + + auto written_register_value_MSB = busCommunication.readRegister( + Reg::Frame_HDR_ModCoord_MSB_Reg); // check if write was successful + + if (register_value_LSB != written_register_value_LSB || + register_value_MSB != written_register_value_MSB) { + throw std::runtime_error( + fmt::format("LSB: requested {}, but set {}. " + "MSB: requested {}, but set {}", + register_value_LSB, written_register_value_LSB, + register_value_MSB, written_register_value_MSB)); + } + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to write module position register: " + << e.what(); + throw; + } +} + +template +slsDetectorDefs::rxParameters +BaseMatterhornServerImpl::get_receiver_parameters() + const { + + slsDetectorDefs::rxParameters rx_params{}; + + rx_params.udpInterfaces = numUDPInterfaces; + + rx_params.udp_dstip = this->udpDetails[0].dstip; + + rx_params.udp_dstport = this->udpDetails[0].dstport; + + rx_params.udp_dstmac = this->udpDetails[0].dstmac; + + rx_params.frames = get_num_frames(); + + rx_params.triggers = get_num_triggers(); + + // TODO: extend + + // rx_params.expTimeNs = 0; + + // rx_params.periodNs = 0; + + // rx_params.dynamicRange = 0; + + // rx_params.timMode = AUTO_TIMING; + + // rx_params.counterMask = 0; + + return rx_params; +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/MatterhornApp.cpp b/slsDetectorServers/matterhornServer/src/MatterhornApp.cpp index 8c37df196..6551bf2f8 100644 --- a/slsDetectorServers/matterhornServer/src/MatterhornApp.cpp +++ b/slsDetectorServers/matterhornServer/src/MatterhornApp.cpp @@ -1,11 +1,13 @@ -#include "CommandLineOptions.h" -#include "VirtualMatterhornServer.h" +#include "CommandLineOptions.hpp" +#include MATTERHORN_SERVER_HEADER +#include "helpers/Helpers.hpp" #include "sls/logger.h" #include "sls/sls_detector_exceptions.h" #include "sls/versionAPI.h" #include #include +#include #include #include #include @@ -62,6 +64,9 @@ int main(int argc, char *argv[]) { LOG(TLogLevel::logINFOMAGENTA) << cli.printOptions(); + // free shared memory from previous run (not removed if detector crashed) + freeSharedMemory(); + // Register Ctrl+C handler std::signal(SIGINT, sigInterruptHandler); @@ -75,11 +80,12 @@ int main(int argc, char *argv[]) { LOG(TLogLevel::logINFOBLUE) << "Stop Server [" << opts.port + 1 << "]"; try { - VirtualMatterhornServer stopServer(opts.port + 1); + MATTERHORN_SERVER_CLASS stopServer(opts.port + 1); while (!interruption) { pause(); // wait for signal to exit } } catch (...) { + LOG(logERROR) << "Some Error occured in Stop Server, exiting"; kill(getppid(), SIGINT); // tell parent to exit // TODO: should then // also return EXIT_FAILURE } @@ -93,13 +99,14 @@ int main(int argc, char *argv[]) { LOG(TLogLevel::logINFOBLUE) << "Control Server [" << opts.port << "]\n"; try { - VirtualMatterhornServer server( + MATTERHORN_SERVER_CLASS server( opts.port); // TODO use virtual if compiled with virtual // simulators on while (!interruption) { pause(); // wait for signal to exit } } catch (...) { + LOG(logERROR) << "Some Error occured in Control Server, exiting"; LOG(sls::logINFOBLUE) << "Exiting Control Server [ Tid: " << gettid() << " ]"; LOG(sls::logINFO) << "Exiting Detector Server"; diff --git a/slsDetectorServers/matterhornServer/src/MatterhornServer.cpp b/slsDetectorServers/matterhornServer/src/MatterhornServer.cpp deleted file mode 100644 index 522d5b486..000000000 --- a/slsDetectorServers/matterhornServer/src/MatterhornServer.cpp +++ /dev/null @@ -1,24 +0,0 @@ -#include "MatterhornServer.h" - -namespace sls { - -MatterhornServer::MatterhornServer(uint16_t port) - : BaseMatterhornServer(port) { - - // TODO: when do i set the udp mac and ip ? - - // should maybe be part of the constructor? - tcpInterface->startTCPServer(); - - // need a function to setup detector - e.g. set all registers etc. -} - -ReturnCode MatterhornServer::initial_checks(ServerInterface &socket) { - - // TODO: add more checks here, for now just return true to be able to test - // the should check firmware -client compatibility - bool initial_checks_passed = true; - return static_cast(socket.sendResult(initial_checks_passed)); -} - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/MatterhornServer.hpp b/slsDetectorServers/matterhornServer/src/MatterhornServer.hpp new file mode 100644 index 000000000..84ba7f96b --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/MatterhornServer.hpp @@ -0,0 +1,41 @@ +#pragma once +#include "BaseMatterhornServer.hpp" +#include "MatterhornServerImpl.hpp" +#include "TCPInterface.hpp" +#include "sls/sls_detector_defs.h" +#include +#include + +namespace sls { + +template +class MatterhornServer + : public BaseMatterhornServer> { + + public: + /** + * Constructor + * Starts up a Matterhorn server. + * Assembles a Matterhorn server using TCP and UDP detector interfaces + * throws an exception in case of failure + * @param port TCP/IP port number + */ + explicit MatterhornServer(uint16_t port = DEFAULT_TCP_CNTRL_PORTNO); + + ~MatterhornServer() = default; +}; + +template +MatterhornServer::MatterhornServer(uint16_t port) + : BaseMatterhornServer>( + std::make_unique>(), port) { + + // should maybe be part of the constructor? + this->tcpInterface->startTCPServer(); + + // TODO: no init_server function for now is it neccessary to set the init + // flag + this->getImpl()->setupDetector(); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/MatterhornServerImpl.hpp b/slsDetectorServers/matterhornServer/src/MatterhornServerImpl.hpp new file mode 100644 index 000000000..9640a273c --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/MatterhornServerImpl.hpp @@ -0,0 +1,70 @@ +#pragma once +#include "BaseMatterhornServerImpl.hpp" + +namespace sls { + +template +class MatterhornServerImpl + : public BaseMatterhornServerImpl> { + + public: + MatterhornServerImpl() = default; + ~MatterhornServerImpl() = default; + + slsDetectorDefs::runStatus get_run_status() const; // TODO: impement + + void set_module_position_and_update_srcudpmac( + const std::array &position_info); + + void set_source_udp_mac([[maybe_unused]] const uint64_t src_mac); +}; + +template +slsDetectorDefs::runStatus +MatterhornServerImpl::get_run_status() const { + + // TODO: will also have a scanStatus - scanStatus should be in base + // implementation and shared between virtual and actual detector - split + // this function into two. + return slsDetectorDefs::runStatus::IDLE; // TODO: implement +} + +template +void MatterhornServerImpl:: + set_module_position_and_update_srcudpmac( + const std::array &position_info) { + + // position_info = [num_modules_in_y, module_index] + + const size_t module_row = position_info[1] % position_info[0]; + if (position_info[0] <= 0) { + throw RuntimeError("Number of modules in y direction cannot be 0."); + } + const size_t module_col = position_info[1] / position_info[0]; + + try { + this->set_module_position(module_row, module_col, position_info[1]); + } catch (const std::exception &e) { + throw RuntimeError("Failed to set module position: " + + std::string(e.what())); + } + + // TODO: update + if (this->udpDetails[0].srcmac == + 0) { // only configure if source mac address is not set already + uint64_t newSrcMac = + 0x000000000000; // TODO: vendor address will be on SOM memory/ + // different for 10G/100G + this->updateSrcMacAddress(newSrcMac); + } +} + +template +void MatterhornServerImpl::set_source_udp_mac( + const uint64_t src_mac) { + + throw RuntimeError( + "Cannot overwrite vendor specific source UDP MAC address."); +} + +} // end namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/VirtualMatterhornServer.cpp b/slsDetectorServers/matterhornServer/src/VirtualMatterhornServer.cpp deleted file mode 100644 index 8c82da20c..000000000 --- a/slsDetectorServers/matterhornServer/src/VirtualMatterhornServer.cpp +++ /dev/null @@ -1,24 +0,0 @@ -#include "VirtualMatterhornServer.h" - -namespace sls { - -VirtualMatterhornServer::VirtualMatterhornServer(uint16_t port) - : BaseMatterhornServer(port) { - - udpDetails[0].srcip = LOCALHOSTIP_INT; - - // should maybe be part of the constructor? - tcpInterface->startTCPServer(); - - // need a function to setup detector - e.g. set all registers etc. -} - -ReturnCode VirtualMatterhornServer::initial_checks(ServerInterface &socket) { - - // TODO: add more checks here, for now just return true to be able to test - // the should check firmware -client compatibility - bool initial_checks_passed = true; - return static_cast(socket.sendResult(initial_checks_passed)); -} - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/VirtualMatterhornServer.hpp b/slsDetectorServers/matterhornServer/src/VirtualMatterhornServer.hpp new file mode 100644 index 000000000..a3c86123e --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/VirtualMatterhornServer.hpp @@ -0,0 +1,39 @@ + +#include "BaseMatterhornServer.hpp" +#include "VirtualMatterhornServerImpl.hpp" + +namespace sls { + +template +class VirtualMatterhornServer + : public BaseMatterhornServer> { + + public: + /** + * Constructor + * Starts up a virtual Matterhorn server. + * Assembles a virtual Matterhorn server using TCP and UDP detector + * interfaces throws an exception in case of failure + * @param port TCP/IP port number + */ + explicit VirtualMatterhornServer(uint16_t port = DEFAULT_TCP_CNTRL_PORTNO); + + ~VirtualMatterhornServer() = default; +}; + +template +VirtualMatterhornServer::VirtualMatterhornServer(uint16_t port) + : BaseMatterhornServer>( + std::make_unique>(), port) { + + LOG(logDEBUG) << "Initializing virtual Matterhorn server on port " << port; + + // should maybe be part of the constructor? + this->tcpInterface->startTCPServer(); + + // TODO: no init_server function for now is it neccessary to set the init + // flag + this->getImpl()->setupDetector(); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/VirtualMatterhornServerImpl.hpp b/slsDetectorServers/matterhornServer/src/VirtualMatterhornServerImpl.hpp new file mode 100644 index 000000000..e442abf6b --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/VirtualMatterhornServerImpl.hpp @@ -0,0 +1,87 @@ +#pragma once +#include "BaseMatterhornServerImpl.hpp" +#include "sls/ToString.h" + +namespace sls { + +template +class VirtualMatterhornServerImpl + : public BaseMatterhornServerImpl< + VirtualMatterhornServerImpl> { + + public: + VirtualMatterhornServerImpl(); + ~VirtualMatterhornServerImpl() = default; + + slsDetectorDefs::runStatus get_run_status() const; + + void set_module_position_and_update_srcudpmac( + const std::array &position_info); + + void set_source_udp_mac(const uint64_t newsrcudpMac); +}; + +template +VirtualMatterhornServerImpl::VirtualMatterhornServerImpl() { + this->set_source_udp_ip(LOCALHOSTIP_INT); +} + +template +slsDetectorDefs::runStatus +VirtualMatterhornServerImpl::get_run_status() const { + + slsDetectorDefs::runStatus scanstatus{}; + slsDetectorDefs::runStatus status{}; + + scanstatus = this->shm()->scanStatus; + status = this->shm()->status; + + // TODO: why only error and running? what about other states? + if (scanstatus == slsDetectorDefs::runStatus::ERROR || + scanstatus == slsDetectorDefs::runStatus::RUNNING) { + LOG(logINFO) << fmt::format("Scan status: {}\n", ToString(scanstatus)); + return scanstatus; + } + + LOG(logINFO) << fmt::format("Status: {}\n", ToString(status)); + return status; +} + +template +void VirtualMatterhornServerImpl:: + set_module_position_and_update_srcudpmac( + const std::array &position_info) { + + const size_t module_row = position_info[1] % position_info[0]; + const size_t module_col = position_info[1] / position_info[0]; + + try { + this->set_module_position(module_row, module_col, position_info[1]); + } catch (const std::exception &e) { + throw RuntimeError("Failed to set module position: " + + std::string(e.what())); + } + + // configure mac address based on module position + if (this->udpDetails[0].srcmac == + 0) { // only configure if source mac address is not set already + uint64_t newSrcMac = + generateMacAddressfromModulePosition(module_row, module_col); + + this->updateSrcMacAddress(newSrcMac); + } +} + +template +void VirtualMatterhornServerImpl::set_source_udp_mac( + const uint64_t newsrcudpMac) { + + if (!isValidMac(newsrcudpMac)) { + throw RuntimeError("Invalid source MAC address: unicast bit or local " + "administration bit is not set"); + } + + this->updateSrcMacAddress(newsrcudpMac); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/communication/SPICommunication.cpp b/slsDetectorServers/matterhornServer/src/communication/SPICommunication.cpp new file mode 100644 index 000000000..8feaffa07 --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/communication/SPICommunication.cpp @@ -0,0 +1,120 @@ +#include "SPICommunication.hpp" +#include +#include +#include +#include +#include + +namespace sls { + +void HardwareSPICommunication::open_spi() { + + // TODO device can change + spi_filedescriptor = open("/dev/spidev2.0", O_RDWR); // TODO use O_SYNC? + + if (spi_filedescriptor < 0) { + throw RuntimeError("Could not open /dev/spidev2.0"); + } + + LOG(logINFO) << fmt::format("SPI Read: opened spidev2.0 with fd={}", + spi_filedescriptor); +} + +void HardwareSPICommunication::close_spi() { + if (spi_filedescriptor >= 0) { + close(spi_filedescriptor); + LOG(logINFO) << "SPI Read: closed spidev2.0"; + spi_filedescriptor = -1; + } +} + +HardwareSPICommunication::~HardwareSPICommunication() { close_spi(); } + +std::vector +HardwareSPICommunication::spi_read(const size_t n_bytes, const uint8_t chip_id, + const uint8_t register_id) const { + + // allocate dummy data to shift out the data (first byte is command byte) + if (n_bytes == std::numeric_limits::max()) { + throw RuntimeError("SPI read size overflow"); + } + + std::vector dummy_data( + n_bytes + 1, std::byte{0x00}); // +1 for the command byte + + // First byte of the message is 4 bits chip_id then 4 bits register_id + dummy_data[0] = + static_cast(((chip_id & 0xF) << 4) | (register_id & 0xF)); + + // allocate data buffer to read out data into + std::vector read_data_buffer(n_bytes + 1, std::byte{0x00}); + + spi_ioc_transfer send_cmd{}; + send_cmd.len = n_bytes + 1; // +1 for the command byte + send_cmd.tx_buf = reinterpret_cast(dummy_data.data()); + send_cmd.rx_buf = reinterpret_cast(read_data_buffer.data()); + + // 0 - Normal operation, 1 - CSN remains zero after operation + // We use cs_change = 1 to not close the SPI transaction and + // allow for shifting the read out data back in to restore the + // register + send_cmd.cs_change = 1; + + // transfer here + if (ioctl(spi_filedescriptor, SPI_IOC_MESSAGE(1), &send_cmd) < 0) { + + throw RuntimeError( + fmt::format("SPI write failed with {}:{}", errno, strerror(errno))); + } + + // copy data to output buffer + std::vector output_data(n_bytes); + std::memcpy(output_data.data(), read_data_buffer.data() + 1, n_bytes); + + // copy the read out data back to the dummy data buffer to shift it back in + send_cmd.tx_buf = send_cmd.rx_buf; + + send_cmd.cs_change = + 0; // end the SPI transaction after shifting back in the data + + if (ioctl(spi_filedescriptor, SPI_IOC_MESSAGE(1), &send_cmd) < 0) { + throw RuntimeError( + fmt::format("SPI write failed with {}:{}", errno, strerror(errno))); + } + + return output_data; +} + +void HardwareSPICommunication::spi_write(const uint8_t chip_id, + const uint8_t register_id, + const std::vector &data) { + + const size_t n_bytes = data.size(); + + if (n_bytes == std::numeric_limits::max()) { + throw RuntimeError("SPI read size overflow"); + } + + // First byte of the message is 4 bits chip_id then 4 bits register_id + std::vector write_data(n_bytes + 1); // +1 for the command byte + + write_data[0] = + static_cast(((chip_id & 0xF) << 4) | (register_id & 0xF)); + + std::memcpy(write_data.data() + 1, data.data(), n_bytes); + + spi_ioc_transfer send_cmd{}; + send_cmd.len = n_bytes + 1; // +1 for the command byte + send_cmd.tx_buf = reinterpret_cast(write_data.data()); + + send_cmd.cs_change = + 0; // end the SPI transaction after the write (we dont need to shift + // back in data here since we are not doing a read) + + if (ioctl(spi_filedescriptor, SPI_IOC_MESSAGE(1), &send_cmd) < 0) { + throw RuntimeError( + fmt::format("SPI write failed with {}:{}", errno, strerror(errno))); + } +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/communication/SPICommunication.hpp b/slsDetectorServers/matterhornServer/src/communication/SPICommunication.hpp new file mode 100644 index 000000000..f74805db9 --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/communication/SPICommunication.hpp @@ -0,0 +1,205 @@ +#include "MemoryModel.hpp" +#include "SPIRegisterHelperStructs.hpp" +#include "defs/MatterhornDefs.hpp" +#include "defs/SPIRegisterDefs.hpp" +#include "fmt/format.h" +#include "sls/logger.h" +#include "sls/sls_detector_exceptions.h" +#include +#include + +namespace sls { + +/// @brief abstract base class for SPI communication +template class SPICommunication { + + public: + SPICommunication() = default; + + ~SPICommunication() = default; + + std::vector SPIread(const SPIRegister &spi_reg, + const uint8_t chip_id) const; + + void SPIwrite(const SPIRegister &spi_reg, const uint8_t chip_id, + const std::vector &data); + + void open_spi(); + + private: + DerivedSPIModel *getDerived() { + return static_cast(this); + } +}; + +template +void SPICommunication::open_spi() { + getDerived()->open_spi(); +} + +template +std::vector +SPICommunication::SPIread(const SPIRegister &spi_reg, + const uint8_t chip_id) const { + + if (chip_id >= MatterhornDefs::NUM_CHIPS_PER_MODULE) { + throw RuntimeError( + fmt::format("Chip id {} is out of range (0-{})", chip_id, + MatterhornDefs::NUM_CHIPS_PER_MODULE - 1)); + } + return static_cast(this)->spi_read( + spi_reg.n_bytes, chip_id, spi_reg.spi_register_id); +} + +template +void SPICommunication::SPIwrite( + const SPIRegister &spi_reg, const uint8_t chip_id, + const std::vector &data) { + + if (chip_id >= MatterhornDefs::NUM_CHIPS_PER_MODULE) { + throw RuntimeError( + fmt::format("Chip id {} is out of range (0-{})", chip_id, + MatterhornDefs::NUM_CHIPS_PER_MODULE - 1)); + } + + if (data.size() != spi_reg.n_bytes) { + throw RuntimeError(fmt::format("Data size {} does not match number of " + "bytes {} for SPI register {}", + data.size(), spi_reg.n_bytes, + spi_reg.spi_register_id)); + } + + getDerived()->spi_write(chip_id, spi_reg.spi_register_id, data); + + getDerived()->spi_write(chip_id, + SPIRegisters::SPI_REG_ExtraClocks.spi_register_id, + std::vector{std::byte{ + 0x00}}); // extra clock trigger to actually load + // the new value into the register +} + +/** + * Non destructive read from SPI register. Read n_bytes by shifting in + * dummy data while keeping csn 0 after the operation. Shift the read out + * data back in to restore the register. + */ +class HardwareSPICommunication + : public SPICommunication { + + public: + HardwareSPICommunication() = default; + + ~HardwareSPICommunication(); + + void open_spi(); + + void spi_write(const uint8_t chip_id, const uint8_t register_id, + const std::vector &data); + + std::vector spi_read(const size_t n_bytes, const uint8_t chip_id, + const uint8_t register_id) const; + + private: + int spi_filedescriptor = -1; + + void close_spi(); +}; + +// template // non +// type template parameters only for c++20 +template // TODO add a type trait to ensure it stores + // all fields +class VirtualSPICommunication + : public SPICommunication> { + + public: + VirtualSPICommunication() { + // TODO should it be in the constructor? + /* + (virtual_registers.emplace( + SPIRegisters.spi_register_id, + VirtualMemoryModel{SPIRegisters.spi_register_id, + SPIRegisters.n_bytes * + NUM_CHIPS_PER_MODULE}), + ...); + */ + + LOG(logDEBUG) << fmt::format( + "Initializing virtual SPI communication with {} registers for {} " + "chips per module", + SPIRegisters::spiregisters.size(), + SPIRegisters::NUM_CHIPS_PER_MODULE); + + for (const auto ® : SPIRegisters::spiregisters) { + virtual_registers.emplace( + reg.spi_register_id, + VirtualMemoryModel{ + reg.spi_register_id, + reg.n_bytes * SPIRegisters::NUM_CHIPS_PER_MODULE}); + } + + LOG(logDEBUG) << fmt::format( + "Initialized virtual SPI communication with {} registers for {} " + "chips per module", + virtual_registers.size(), SPIRegisters::NUM_CHIPS_PER_MODULE); + + for (const auto &[register_id, register_memory] : virtual_registers) { + LOG(logDEBUG) << fmt::format( + "Virtual SPI register with id {} has virtual", register_id); + } + } + + ~VirtualSPICommunication() = default; + + void open_spi() { + + // resize the virtual register memory to the correct size based on + // the defined SPI registers + for (auto &[register_id, register_memory] : virtual_registers) { + LOG(logDEBUG) << fmt::format("Mapping virtual SPI register with id " + "{} to virtual memory", + register_id); + register_memory.mapToMemory(); + } + } + + std::vector spi_read(const size_t n_bytes, const uint8_t chip_id, + const uint8_t register_id) const { + + auto mapped_register = + virtual_registers.at(register_id).getMappedMemoryPtr(); + + mapped_register += + chip_id * n_bytes; // TODO: how to handle different chip ids -> + // e.g. broadcast do we want it to be + // configurable for different chip ids? + + // TODO: should I emulate the shifting in of dummy data and shifting + // out of the register data here to be more realistic? + std::vector output_data(n_bytes); + std::memcpy(output_data.data(), mapped_register, n_bytes); + + return output_data; + } + + void spi_write(const uint8_t chip_id, const uint8_t register_id, + const std::vector &data) { + + auto mapped_register = + virtual_registers.at(register_id).getMappedMemoryPtr(); + + mapped_register += + chip_id * data.size(); // TODO: how to handle different + // chip ids -> e.g. broadcast do + + // TODO: should I emulate the shifting in of dummy data and shifting + // out of + std::memcpy(mapped_register, data.data(), data.size()); + } + + private: + /// @brief map of register id to virtual memory model for each register + std::map> virtual_registers{}; +}; + +} // namespace sls diff --git a/slsDetectorServers/matterhornServer/src/communication/SPIRegisterHelperStructs.hpp b/slsDetectorServers/matterhornServer/src/communication/SPIRegisterHelperStructs.hpp new file mode 100644 index 000000000..a0dc85afb --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/communication/SPIRegisterHelperStructs.hpp @@ -0,0 +1,87 @@ +#pragma once +#include "fmt/format.h" +#include +#include + +namespace sls { + +struct SPIRegister { + /// @brief SPI register ID (0-15) + uint16_t spi_register_id{}; + + /// @brief number of bytes in the register + uint64_t n_bytes{}; +}; + +struct SPIRegisterField { + /// @brief SPI register to which teh field belongs + SPIRegister register_{}; + + /// @brief least significant bit position of the field in the register + uint64_t lsb_position{}; + + /// @brief number of bits in the field + /// TODO: can it be larger? + uint32_t num_bits{}; +}; + +// TODO: maybe change uint32_t but max field size is 32 bits so should be fine +// for now +void inline setSPIRegisterField(std::vector ®ister_value, + const SPIRegisterField &field, + uint32_t field_value) { + + // check that the field value can fit in the bitmask + if ((field_value >> field.num_bits) != 0) { + throw std::invalid_argument(fmt::format( + "Value {} cannot fit in field {}", field_value, field.num_bits)); + } + + constexpr uint8_t bits_per_byte = 8; + + // TODO: mmh doesnt feel very modern - maybe better to cast to uint32_t, + // alignment issues? + for (std::size_t i = 0; i < field.num_bits; ++i) { + std::size_t offset = field.lsb_position + i; + std::size_t byte_index = offset / bits_per_byte; + std::size_t bit_index = offset % bits_per_byte; + + std::byte mask = std::byte(1) << bit_index; + + const bool bit = (field_value >> i) & 0x1; + + if (bit) { + register_value[byte_index] |= + mask; // set the bit in the register value + } else { + register_value[byte_index] &= + ~mask; // clear the bit in the register value + } + } +} + +uint32_t inline getSPIRegisterField( + const std::vector ®ister_value, + const SPIRegisterField &field) { + + uint32_t field_value = 0; + constexpr uint8_t bits_per_byte = 8; + + for (std::size_t i = 0; i < field.num_bits; ++i) { + std::size_t offset = field.lsb_position + i; + std::size_t byte_index = offset / bits_per_byte; + std::size_t bit_index = offset % bits_per_byte; + + std::byte mask = std::byte(1) << bit_index; + + field_value |= + (static_cast((register_value[byte_index] & mask) >> + bit_index) + << i); // extract the field value bit from the register value and + // set it in the correct position in the field value + } + + return field_value; +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/defs/MatterhornDefs.hpp b/slsDetectorServers/matterhornServer/src/defs/MatterhornDefs.hpp new file mode 100644 index 000000000..d49115d52 --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/defs/MatterhornDefs.hpp @@ -0,0 +1,50 @@ +#pragma once +#include "RegisterDefs.hpp" +#include "SPIRegisterDefs.hpp" +#include +#include + +namespace sls { + +namespace MatterhornDefs { + +constexpr uint8_t NUM_CHIPS_PER_MODULE = 8; + +// TODO: should probably be a specialized template struct + +/// @brief list of Matterhorn SPI registers +struct MatterhornSPIRegisters { + + constexpr static std::array spiregisters{ + SPIRegisters::SPI_REG_ConfigUnit, + SPIRegisters::SPI_REG_ConfigCML, + SPIRegisters::SPI_REG_ManualSelector, + SPIRegisters::SPI_REG_CoreRSTUnit, + SPIRegisters::SPI_REG_StoreRSTUnit, + SPIRegisters::SPI_REG_Trimbits, + SPIRegisters::SPI_REG_McGyver, + SPIRegisters::SPI_REG_McGyver_par_load, + SPIRegisters::SPI_REG_ActionReg, + SPIRegisters::SPI_REG_InternalDACs, + SPIRegisters::SPI_REG_ChecksumReg, + SPIRegisters::SPI_REG_ExtraClocks}; + + constexpr static uint8_t NUM_CHIPS_PER_MODULE = + MatterhornDefs::NUM_CHIPS_PER_MODULE; +}; + +/// @brief list of Matterhorn IP cores +struct MatterHornIPCores { + + using ipcore_enum_type = IPCore; + + constexpr static std::array ipcores{ + IPCore::MH_RO_SM_AXI, IPCore::FHDR_AXI, IPCore::AURORA_STATUS, + IPCore::AURORA_STATUS2, IPCore::PACKETIZERREG}; + + constexpr static size_t ip_core_block_size = IPCORE_REGISTER_BLOCK_SIZE; +}; + +} // namespace MatterhornDefs + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/include/RegisterDefs.hpp b/slsDetectorServers/matterhornServer/src/defs/RegisterDefs.hpp similarity index 80% rename from slsDetectorServers/matterhornServer/include/RegisterDefs.hpp rename to slsDetectorServers/matterhornServer/src/defs/RegisterDefs.hpp index 60335ccb4..51297d2f3 100644 --- a/slsDetectorServers/matterhornServer/include/RegisterDefs.hpp +++ b/slsDetectorServers/matterhornServer/src/defs/RegisterDefs.hpp @@ -1,19 +1,27 @@ // clang-format off +#pragma once #include "RegisterHelperStructs.hpp" namespace sls { /// @brief Enum for IP cores, value are adresses -constexpr enum class IPCore : uint32_t { - MH_RO_SM_AXI = 0, // dummy adresses for now - FHDR_AXI = 1, - AURORA_STATUS = 2, - AURORA_STATUS2 = 3, - PACKETIZERREG = 4, - UNKNOWN = 5 +enum class IPCore : uint32_t { + MH_RO_SM_AXI = 0xB0010000, + FHDR_AXI = 0xB0011000, + AURORA_STATUS = 0xB0014000, + AURORA_STATUS2 = 0xB0015000, + PACKETIZERREG = 0x00000000, // TODO: need to update with actual address + UNKNOWN = 0x00000000 // dont know yet }; +constexpr size_t IPCORE_REGISTER_BLOCK_SIZE = + 0x1000; // size of each IP core address space in bytes // TODO: maybe add in + // other file definitions + +// clang-format off +namespace Reg { + // Register definitions constexpr Register CTRL_Reg{IPCore::UNKNOWN, 0x0}; @@ -22,7 +30,7 @@ constexpr Register Status_Reg{IPCore::UNKNOWN, 0x4}; constexpr Register FPGAVersionReg{IPCore::UNKNOWN, 0x8}; -constexpr Register FPGA_GIT_HEAD{IPCore::UNKNOWN, 0xc}; +constexpr Register FPGA_GIT_HEADReg{IPCore::UNKNOWN, 0xc}; constexpr Register FixedPatternReg{IPCore::UNKNOWN, 0x10}; @@ -42,6 +50,8 @@ constexpr Register MH_SM_StoreLength_Reg{IPCore::MH_RO_SM_AXI, 0x10}; constexpr Register MH_SM_ResetMHLength_Reg{IPCore::MH_RO_SM_AXI, 0x14}; +constexpr Register MH_SM_Triggers_Reg{IPCore::MH_RO_SM_AXI, 0x18}; + constexpr Register Frame_HDR_Set_Reg{IPCore::FHDR_AXI, 0x0}; constexpr Register Frame_HDR_FrameNumLSB_Reg{IPCore::FHDR_AXI, 0x4}; @@ -116,7 +126,7 @@ constexpr RegisterField FPGADetType{ FPGAVersionReg, 24, 0xff}; constexpr RegisterField FPGA_GIT_HEAD{ - FPGA_GIT_HEAD, 0, 0xffffffff}; + FPGA_GIT_HEADReg, 0, 0xffffffff}; constexpr RegisterField FixedPattern{ FixedPatternReg, 0, 0xffffffff}; @@ -136,6 +146,24 @@ constexpr RegisterField Start_Acquistion{ constexpr RegisterField Stop_Acquistion{ MH_SM_Ctrl_Reg, 1, 0x1}; +constexpr RegisterField External_Counter_Enable{ + MH_SM_Ctrl_Reg, 2, 0x1}; + +constexpr RegisterField Parallel_RO{ + MH_SM_Ctrl_Reg, 3, 0x1}; + +constexpr RegisterField Trigger_Mode{ + MH_SM_Ctrl_Reg, 4, 0x3}; + +constexpr RegisterField HW_Trigger_Polarity{ + MH_SM_Ctrl_Reg, 6, 0x1}; + +constexpr RegisterField SW_Trigger{ + MH_SM_Ctrl_Reg, 7, 0x1}; + +constexpr RegisterField Reset_Readout_SM{ + MH_SM_Ctrl_Reg, 8, 0x1}; + constexpr RegisterField MH_Readout_Exposure_Time{ MH_SM_Exposure_Reg, 0, 0xffffffff}; @@ -151,6 +179,9 @@ constexpr RegisterField MH_SM_StoreLength{ constexpr RegisterField MH_SM_ResetMHLength{ MH_SM_ResetMHLength_Reg, 0, 0xffffffff}; +constexpr RegisterField MH_SM_Triggers{ + MH_SM_Triggers_Reg, 0, 0xffffffff}; + constexpr RegisterField Frame_Hdr_Set_Framenumber{ Frame_HDR_Set_Reg, 0, 0x1}; @@ -236,5 +267,17 @@ constexpr RegisterField Coordz{ PktCoordReg2, 0, 0xffff}; +constexpr RegisterField ModuleRow{ + Frame_HDR_ModCoord_LSB_Reg, 0, 0xffff}; + +constexpr RegisterField ModuleCol{ + Frame_HDR_ModCoord_LSB_Reg, 16, 0xffff}; + +constexpr RegisterField ModuleCoordz{ + Frame_HDR_ModCoord_MSB_Reg, 0, 0xffff}; + +constexpr RegisterField ModuleIndex{ + Frame_HDR_ModCoord_MSB_Reg, 16, 0xffff}; +} // namespace Reg } // namespace sls // clang-format on diff --git a/slsDetectorServers/matterhornServer/src/defs/SPIRegisterDefs.hpp b/slsDetectorServers/matterhornServer/src/defs/SPIRegisterDefs.hpp new file mode 100644 index 000000000..7f29f3b63 --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/defs/SPIRegisterDefs.hpp @@ -0,0 +1,51 @@ +#pragma once +#include "SPIRegisterHelperStructs.hpp" +#include + +namespace sls { + +namespace SPIRegisters { + +// SPI registers +constexpr SPIRegister SPI_REG_ConfigUnit{0, 8}; + +constexpr SPIRegister SPI_REG_ConfigCML{1, 1}; + +constexpr SPIRegister SPI_REG_ManualSelector{2, 2}; + +constexpr SPIRegister SPI_REG_CoreRSTUnit{3, 4}; + +constexpr SPIRegister SPI_REG_StoreRSTUnit{4, 2}; + +constexpr SPIRegister SPI_REG_Trimbits{5, 256}; + +constexpr SPIRegister SPI_REG_McGyver{6, 512}; + +constexpr SPIRegister SPI_REG_McGyver_par_load{7, 512}; + +constexpr SPIRegister SPI_REG_ActionReg{11, 1}; + +constexpr SPIRegister SPI_REG_InternalDACs{13, 4}; + +constexpr SPIRegister SPI_REG_ChecksumReg{14, 32}; + +// Used to generate extra clocks after writing to trigger the load of the new +// value +constexpr SPIRegister SPI_REG_ExtraClocks{12, + 1}; // TODO: dont know what size is + +// SPI register fields +constexpr SPIRegisterField OUTPUT_MODE{SPI_REG_ConfigUnit, 4, 3}; + +/// @brief first two bits starting counter, second two bits number of counters +/// to read e.g. 0b0100 -> read counter 0 and 1, 0b0001 -> read counter 1 +constexpr SPIRegisterField NUM_COUNTERS{SPI_REG_ConfigUnit, 8, 4}; + +/// @brief 00-> 16 bit, 01 -> 8 bit, 10 -> 4 bit, 11 -> reserved 16 bit +constexpr SPIRegisterField DYNAMIC_RANGE{SPI_REG_ConfigUnit, 14, 2}; + +// TODO: continue defining the rest of the fields as needed + +} // namespace SPIRegisters + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/utils/HelperFunctions.cpp b/slsDetectorServers/matterhornServer/src/utils/HelperFunctions.cpp new file mode 100644 index 000000000..336517f3d --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/utils/HelperFunctions.cpp @@ -0,0 +1,75 @@ +#include "HelperFunctions.hpp" +#include + +namespace sls { + +uint32_t convertCounterMaskToSPICounterMask(const uint32_t counter_mask) { + uint32_t spi_counter_mask = 0; + + switch (counter_mask) { + case 0b1: + spi_counter_mask = 0b0000; // counter 0 enabled + break; + case 0b10: + spi_counter_mask = 0b0001; // counter 1 enabled + break; + case 0b100: + spi_counter_mask = 0b0010; // counter 2 enabled + break; + case 0b1000: + spi_counter_mask = 0b0011; // counter 3 enabled + break; + case 0b11: + spi_counter_mask = 0b0100; // counter 0 and 1 enabled + break; + case 0b110: + spi_counter_mask = 0b0101; // counter 1 and 2 enabled + break; + case 0b1100: + spi_counter_mask = 0b0110; // counter 2 and 3 enabled + break; + case 0b1001: + spi_counter_mask = 0b0111; // counter 0 and 3 enabled + break; + case 0b111: + spi_counter_mask = 0b1000; // counter 0, 1 and 2 enabled + break; + case 0b1110: + spi_counter_mask = 0b1001; // counter 1, 2 and 3 enabled + break; + case 0b1101: + spi_counter_mask = 0b1010; // counter 0, 2 and 3 enabled + break; + case 0b1011: + spi_counter_mask = 0b1011; // counter 0, 1 and 3 enabled + break; + case 0b1111: + spi_counter_mask = 0b1100; // counter 0, 1, 2 and 3 enabled + break; + default: + throw std::invalid_argument( + "Invalid counter mask: Only contiguous counters are enabled " + "(including wrap around)"); + } + + return spi_counter_mask; +} + +uint32_t convertSPICounterMaskToCounterMask(const uint32_t spi_counter_mask) { + + uint32_t counter_mask{}; + + uint8_t start_counter = spi_counter_mask & 0b11; // extract starting counter + uint8_t num_counters = + ((spi_counter_mask >> 2) & 0b11) + 1; // extract number of counters + + constexpr uint8_t max_counters = 4; + + for (uint8_t i = 0; i < num_counters; ++i) { + counter_mask |= (1 << ((start_counter + i) % max_counters)); + } + + return counter_mask; +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/src/utils/HelperFunctions.hpp b/slsDetectorServers/matterhornServer/src/utils/HelperFunctions.hpp new file mode 100644 index 000000000..550a8bd8a --- /dev/null +++ b/slsDetectorServers/matterhornServer/src/utils/HelperFunctions.hpp @@ -0,0 +1,26 @@ +/** + * @file HelperFunctions.hpp + * @short contains helper functions for the Matterhorn server implementation + * e.g. for processing of specific commands + */ +#include + +namespace sls { + +/** + * @brief converts the counter mask received from the client to the actual + * counter mask to be written to the SPI register based on the starting counter + * and number of counters to read + * @return actual counter mask to be written to the SPI register + */ +uint32_t convertCounterMaskToSPICounterMask(const uint32_t counter_mask); + +/** + * @brief converts the actual counter mask read from the SPI register to the + * counter mask to be sent to the client e.g. bit set to 1 if counter + * enabled + * @return counter mask to be sent to the client + */ +uint32_t convertSPICounterMaskToCounterMask(const uint32_t spi_counter_mask); + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/tests/CMakeLists.txt b/slsDetectorServers/matterhornServer/tests/CMakeLists.txt new file mode 100644 index 000000000..e4b6e4cfb --- /dev/null +++ b/slsDetectorServers/matterhornServer/tests/CMakeLists.txt @@ -0,0 +1,9 @@ + +target_sources(tests PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/test-HelperFunctions.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../src/utils/HelperFunctions.cpp +) + +target_include_directories(tests + PUBLIC + "$") diff --git a/slsDetectorServers/matterhornServer/tests/test-HelperFunctions.cpp b/slsDetectorServers/matterhornServer/tests/test-HelperFunctions.cpp new file mode 100644 index 000000000..0cbf93e13 --- /dev/null +++ b/slsDetectorServers/matterhornServer/tests/test-HelperFunctions.cpp @@ -0,0 +1,48 @@ +#include "HelperFunctions.hpp" +#include "catch.hpp" +#include + +namespace sls { + +auto get_test_parameters_countermaskspiconversion() { + return GENERATE(std::make_tuple(uint32_t{0x1}, uint32_t{0b0000}), + std::make_tuple(uint32_t{0x2}, uint32_t{0b0001}), + std::make_tuple(uint32_t{0x4}, uint32_t{0b0010}), + std::make_tuple(uint32_t{0x3}, uint32_t{0b0100}), + std::make_tuple(uint32_t{0x6}, uint32_t{0b0101}), + std::make_tuple(uint32_t{0x7}, uint32_t{0b1000}), + std::make_tuple(uint32_t{0x8}, uint32_t{0b0011}), + std::make_tuple(uint32_t{0x9}, uint32_t{0b0111}), + std::make_tuple(uint32_t{0xB}, uint32_t{0b1011}), + std::make_tuple(uint32_t{0xC}, uint32_t{0b0110}), + std::make_tuple(uint32_t{0xD}, uint32_t{0b1010}), + std::make_tuple(uint32_t{0xE}, uint32_t{0b1001}), + std::make_tuple(uint32_t{0xF}, uint32_t{0b1100}), + std::make_tuple(uint32_t{0xB}, uint32_t{0b1011})); +} + +TEST_CASE("Convert Counter Mask to SPI Counter Mask", + "[MatterHorn][HelperFunctions]") { + auto [counter_mask, expected_spi_counter_mask] = + get_test_parameters_countermaskspiconversion(); + + REQUIRE(convertCounterMaskToSPICounterMask(counter_mask) == + expected_spi_counter_mask); + + REQUIRE_THROWS( + convertCounterMaskToSPICounterMask(0xA)); // invalid counter mask + + REQUIRE_THROWS( + convertCounterMaskToSPICounterMask(0x5)); // invalid counter mask +} + +TEST_CASE("Convert SPI Counter Mask to Counter Mask", + "[MatterHorn][HelperFunctions]") { + auto [counter_mask, spi_counter_mask] = + get_test_parameters_countermaskspiconversion(); + + REQUIRE(convertSPICounterMaskToCounterMask(spi_counter_mask) == + counter_mask); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/matterhornServer/toolchain.cmake b/slsDetectorServers/matterhornServer/toolchain.cmake new file mode 100644 index 000000000..d9b669799 --- /dev/null +++ b/slsDetectorServers/matterhornServer/toolchain.cmake @@ -0,0 +1,17 @@ +#Usage: cmake .. -DCMAKE_TOOLCHAIN_FILE=toolchain.cmake -DSLS_BUILD_ONLY_MATTERHORN=ON + +set(SLS_ARM_COMPILER "/psi.ch/group/detector/firmware/arm64_linux/arm-gnu-toolchain-12.3.rel1-x86_64-aarch64-none-linux-gnu/" CACHE PATH "Path to the ARM cross compiler") + +set(CMAKE_SYSTEM_NAME Linux) +set(CMAKE_SYSTEM_PROCESSOR aarch64) + +set(CMAKE_C_COMPILER "${SLS_ARM_COMPILER}/bin/aarch64-none-linux-gnu-gcc") +set(CMAKE_CXX_COMPILER "${SLS_ARM_COMPILER}/bin/aarch64-none-linux-gnu-g++") + +set(CMAKE_AR "${SLS_ARM_COMPILER}/bin/aarch64-none-linux-gnu-ar") +set(CMAKE_RANLIB "${SLS_ARM_COMPILER}/bin/aarch64-none-linux-gnu-ranlib") + +set(CMAKE_FIND_ROOT_PATH "${SLS_ARM_COMPILER}") +set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) +set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) + diff --git a/slsDetectorServers/slsDetectorServer_cpp/CMakeLists.txt b/slsDetectorServers/slsDetectorServer_cpp/CMakeLists.txt index 9060b99f2..4d9e50eeb 100644 --- a/slsDetectorServers/slsDetectorServer_cpp/CMakeLists.txt +++ b/slsDetectorServers/slsDetectorServer_cpp/CMakeLists.txt @@ -1,6 +1,8 @@ set(SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/TCPInterface.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/CommandLineOptions.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/MemoryModel.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/src/DetectorServerImpl.cpp ) add_library(slsServerObject OBJECT @@ -23,13 +25,13 @@ target_link_libraries(slsServerObject set(DETECTOR_LIBRARY_TARGETS slsServerObject) set(PUBLICHEADERS - ${CMAKE_CURRENT_SOURCE_DIR}/include/TCPInterface.h + ${CMAKE_CURRENT_SOURCE_DIR}/include/TCPInterface.hpp ) #Shared library if(SLS_BUILD_SHARED_LIBRARIES) add_library(slsServerShared SHARED $) - target_link_libraries(slsServerShared PUBLIC slsServerObject) + target_link_libraries(slsServerShared PUBLIC slsServerObject PRIVATE slsProjectWarnings) set_target_properties(slsServerShared PROPERTIES VERSION ${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_PATCH} SOVERSION ${PACKAGE_VERSION_MAJOR} @@ -42,7 +44,7 @@ endif(SLS_BUILD_SHARED_LIBRARIES) #Static library add_library(slsServerStatic STATIC $) -target_link_libraries(slsServerStatic PUBLIC slsServerObject) +target_link_libraries(slsServerStatic PUBLIC slsServerObject PRIVATE slsProjectWarnings) set_target_properties(slsServerStatic PROPERTIES ARCHIVE_OUTPUT_NAME SlsServerStatic diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/ArmBusCommunication.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/ArmBusCommunication.hpp new file mode 100644 index 000000000..5b43bf16f --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/ArmBusCommunication.hpp @@ -0,0 +1,87 @@ +#pragma once +#include "RegisterHelperStructs.hpp" +#include "fmt/format.h" +#include +#include +#include +#include +#include +#include +#include + +// TODO: maybe should be templated on address type (e.g. uint32_t register or +// uint64_t register) for more flexibility? + +namespace sls { + +template class BusCommunication { + + using IPCoreEnumType = typename IPCores::ipcore_enum_type; + + public: + BusCommunication(); + + void mapToMemory(); + + uint32_t readRegister(const Register ®ister_) const; + void writeRegister(const Register ®ister_, const uint32_t data); + + private: + void bus_w(const uint32_t offset, IPCoreEnumType baseadress, + const uint32_t data); + + uint32_t bus_r(const uint32_t offset, IPCoreEnumType baseadress) const; + + /// @brief map from id of IP Core to memory model for the register block of + /// the IP core + std::map ipcoreregisterblocks{}; +}; + +template +BusCommunication::BusCommunication() { + + for (const auto &ip_core : IPCores::ipcores) { + ipcoreregisterblocks.emplace(ip_core, + MemoryModel{static_cast(ip_core), + IPCores::ip_core_block_size}); + } +} + +template +void BusCommunication::mapToMemory() { + + for (auto &map_elem : ipcoreregisterblocks) { + map_elem.second.mapToMemory(); + } +} + +template +uint32_t BusCommunication::readRegister( + const Register ®ister_) const { + return bus_r(register_.offset_in_bytes, register_.ip_core); +} + +template +void BusCommunication::writeRegister( + const Register ®ister_, const uint32_t data) { + bus_w(register_.offset_in_bytes, register_.ip_core, data); +} + +template +uint32_t BusCommunication::bus_r( + const uint32_t offset, const IPCoreEnumType baseadress) const { + auto ptr1 = ipcoreregisterblocks.at(baseadress).getMappedMemoryPtr() + + offset / (sizeof(uint32_t)); + return *ptr1; +} + +template +void BusCommunication::bus_w( + const uint32_t offset, const IPCoreEnumType baseadress, + const uint32_t data) { + auto ptr1 = ipcoreregisterblocks.at(baseadress).getMappedMemoryPtr() + + offset / (sizeof(uint32_t)); + *ptr1 = data; +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/CommandLineOptions.h b/slsDetectorServers/slsDetectorServer_cpp/include/CommandLineOptions.hpp similarity index 100% rename from slsDetectorServers/slsDetectorServer_cpp/include/CommandLineOptions.h rename to slsDetectorServers/slsDetectorServer_cpp/include/CommandLineOptions.hpp diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServer.h b/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServer.h deleted file mode 100644 index 6773f17ba..000000000 --- a/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServer.h +++ /dev/null @@ -1,271 +0,0 @@ -#pragma once -#include "TCPInterface.h" -// #include "communication_funcs.h" -#include "sls/logger.h" -#include "sls/network_utils.h" -#include "sls/sls_detector_defs.h" -#include "sls/versionAPI.h" -#include -#include -#include -#include -#include -#include - -namespace sls { - -// TODO move to defs? -/// @brief struct saving udp details (one UDP port per module) -struct UDPInfo { - uint16_t srcport{}; - uint16_t dstport{}; - uint64_t srcmac{}; - uint64_t dstmac{}; - uint32_t srcip{}; - uint32_t dstip{}; -}; - -using ReturnCode = slsDetectorDefs::ReturnCode; - -template class DetectorServer { - - public: - /** - * Constructor - * Creates a detector server. - * Assembles a detector server using TCP and UDP detector interfaces - * throws an exception in case of failure - * @param port TCP/IP port number - */ - explicit DetectorServer(uint16_t port = DEFAULT_TCP_CNTRL_PORTNO); - - protected: - /// @brief TCP/IP interface for communication with the client - std::unique_ptr tcpInterface; - - std::array - udpDetails{}; // TODO: for now only one receiver per module - - /// @brief TODO what is this? - bool updateMode{true}; - - private: - ReturnCode processFunction(const detFuncs function_id, - ServerInterface &socket); - - // TODO dont know what this does? - ReturnCode get_update_mode(ServerInterface &socket) const; - - ReturnCode get_source_udp_mac(ServerInterface &socket) const; - - ReturnCode set_source_udp_mac(ServerInterface &socket); - - ReturnCode get_source_udp_ip(ServerInterface &socket) const; - - ReturnCode set_source_udp_ip(ServerInterface &socket); - - ReturnCode get_source_udp_port(ServerInterface &socket) const; - - ReturnCode set_destination_udp_mac(ServerInterface &socket); - - ReturnCode get_destination_udp_mac(ServerInterface &socket) const; - - ReturnCode set_destination_udp_ip(ServerInterface &socket); - - ReturnCode get_destination_udp_ip(ServerInterface &socket) const; - - ReturnCode set_destination_udp_port(ServerInterface &socket); - - ReturnCode get_destination_udp_port(ServerInterface &socket) const; -}; - -template -DetectorServer::DetectorServer(uint16_t port) { - validatePortNumber(port); - - udpDetails[0].srcport = DEFAULT_UDP_SRC_PORTNO; - udpDetails[0].dstport = DEFAULT_UDP_DST_PORTNO; - - std::function fn = - [this](const detFuncs &function_id, ServerInterface &socket) { - return this->processFunction(function_id, socket); - }; - tcpInterface = std::make_unique(fn, port); -} - -template -ReturnCode DetectorServer::processFunction( - const detFuncs function_id, ServerInterface &socket) { - - switch (function_id) { - case detFuncs::F_GET_SERVER_VERSION: - return static_cast(this)->get_version(socket); - case detFuncs::F_GET_DETECTOR_TYPE: - return static_cast(this)->get_detector_type( - socket); - case detFuncs::F_INITIAL_CHECKS: - return static_cast(this)->initial_checks( - socket); - case detFuncs::F_GET_NUM_INTERFACES: - return static_cast(this) - ->get_num_udp_interfaces(socket); - case detFuncs::F_GET_UPDATE_MODE: - return get_update_mode(socket); - case detFuncs::F_SET_SOURCE_UDP_MAC: - return set_source_udp_mac(socket); - case detFuncs::F_GET_SOURCE_UDP_MAC: - return get_source_udp_mac(socket); - case detFuncs::F_SET_SOURCE_UDP_IP: - return set_source_udp_ip(socket); - case detFuncs::F_GET_SOURCE_UDP_IP: - return get_source_udp_ip(socket); - case detFuncs::F_SET_DEST_UDP_MAC: - return set_destination_udp_mac(socket); - case detFuncs::F_GET_DEST_UDP_MAC: - return get_destination_udp_mac(socket); - case detFuncs::F_SET_DEST_UDP_IP: - return set_destination_udp_ip(socket); - case detFuncs::F_GET_DEST_UDP_IP: - return get_destination_udp_ip(socket); - case detFuncs::F_SET_DEST_UDP_PORT: - return set_destination_udp_port(socket); - case detFuncs::F_GET_DEST_UDP_PORT: - return get_destination_udp_port(socket); - - default: - LOG(logDEBUG) << "Checking specific server functions for function ID: " - << function_id; - // process detector specific functions - static_cast(this)->processFunction(function_id, - socket); - } - - return ReturnCode::FAIL; -} - -template -ReturnCode DetectorServer::get_update_mode( - ServerInterface &socket) const { - - return static_cast( - socket.sendResult(static_cast(updateMode))); -} - -template -ReturnCode DetectorServer::set_source_udp_mac( - ServerInterface &socket) { - uint64_t newsrcudpMac; - - try { - int ret = socket.Receive(newsrcudpMac); - } catch (const SocketError &e) { - LOG(logERROR) << "Failed to receive new source UDP MAC address: " - << e.what(); - return ReturnCode::FAIL; - } - - udpDetails[0].srcmac = newsrcudpMac; - // TODO: configuremac, check unicast address - return ReturnCode::OK; -} - -template -ReturnCode DetectorServer::get_source_udp_mac( - ServerInterface &socket) const { - return static_cast(socket.sendResult(udpDetails[0].srcmac)); -} - -template -ReturnCode DetectorServer::set_source_udp_ip( - ServerInterface &socket) { - uint32_t newSrcIp; - - try { - int ret = socket.Receive(newSrcIp); - } catch (const SocketError &e) { - LOG(logERROR) << "Failed to receive new source UDP IP address: " - << e.what(); - return ReturnCode::FAIL; - } - - udpDetails[0].srcip = newSrcIp; - return ReturnCode::OK; -} - -template -ReturnCode DetectorServer::get_source_udp_ip( - ServerInterface &socket) const { - return static_cast(socket.sendResult(udpDetails[0].srcip)); -} - -template -ReturnCode DetectorServer::set_destination_udp_mac( - ServerInterface &socket) { - uint64_t newDstMac; - - try { - int ret = socket.Receive(newDstMac); - } catch (const SocketError &e) { - LOG(logERROR) << "Failed to receive new destination UDP MAC address: " - << e.what(); - return ReturnCode::FAIL; - } - - udpDetails[0].dstmac = newDstMac; - // TODO: configuremac, check unicast address - return ReturnCode::OK; -} - -template -ReturnCode DetectorServer::get_destination_udp_mac( - ServerInterface &socket) const { - return static_cast(socket.sendResult(udpDetails[0].dstmac)); -} - -template -ReturnCode DetectorServer::set_destination_udp_ip( - ServerInterface &socket) { - uint32_t newDstIp; - - try { - int ret = socket.Receive(newDstIp); - } catch (const SocketError &e) { - LOG(logERROR) << "Failed to receive new destination UDP IP address: " - << e.what(); - return ReturnCode::FAIL; - } - - udpDetails[0].dstip = newDstIp; - return ReturnCode::OK; -} - -template -ReturnCode DetectorServer::get_destination_udp_ip( - ServerInterface &socket) const { - return static_cast(socket.sendResult(udpDetails[0].dstip)); -} - -template -ReturnCode DetectorServer::set_destination_udp_port( - ServerInterface &socket) { - uint16_t newDstPort; - - try { - int ret = socket.Receive(newDstPort); - } catch (const SocketError &e) { - LOG(logERROR) << "Failed to receive new destination UDP port number: " - << e.what(); - return ReturnCode::FAIL; - } - - udpDetails[0].dstport = newDstPort; - return ReturnCode::OK; -} - -template -ReturnCode DetectorServer::get_destination_udp_port( - ServerInterface &socket) const { - return static_cast(socket.sendResult(udpDetails[0].dstport)); -}; - -} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServer.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServer.hpp new file mode 100644 index 000000000..9039bd080 --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServer.hpp @@ -0,0 +1,523 @@ +#pragma once +#include "DetectorServerImpl.hpp" +#include "TCPInterface.hpp" +#include "helpers/Helpers.hpp" +#include "helpers/type_traits.hpp" +#include "sls/logger.h" +#include "sls/network_utils.h" +#include "sls/sls_detector_defs.h" +#include "sls/versionAPI.h" +#include +#include +#include +#include +#include +#include + +namespace sls { + +using ReturnCode = slsDetectorDefs::ReturnCode; + +template class DetectorServer { + + public: + /** + * Constructor + * Creates a detector server. + * Assembles a detector server using TCP and UDP detector interfaces + * throws an exception in case of failure + * @param port TCP/IP port number + */ + explicit DetectorServer( + std::unique_ptr< + DetectorServerImpl::value>> + impl_, + uint16_t port = DEFAULT_TCP_CNTRL_PORTNO); + + ~DetectorServer() = default; + + protected: + /// @brief TCP/IP interface for communication with the client + std::unique_ptr tcpInterface; + + std::unique_ptr< + DetectorServerImpl::value>> + impl; + + auto *getImpl() { + return static_cast::ImplType *>(impl.get()); + } + + const auto *getImpl() const { + return static_cast::ImplType *>(impl.get()); + } + + private: + /// @brief get derived class + DerivedDetectorServer *getDerived() { + return static_cast(this); + } + + const DerivedDetectorServer *getDerived() const { + return static_cast(this); + } + + ProcessedResult processFunction(const detFuncs function_id, + ServerInterface &socket); + + // TODO dont know what this does? + ProcessedResult get_update_mode(ServerInterface &socket) const; + + ProcessedResult get_source_udp_mac(ServerInterface &socket) const; + + ProcessedResult set_source_udp_mac(ServerInterface &socket); + + ProcessedResult get_source_udp_ip(ServerInterface &socket) const; + + ProcessedResult set_source_udp_ip(ServerInterface &socket); + + ProcessedResult get_source_udp_port(ServerInterface &socket) const; + + ProcessedResult set_destination_udp_mac(ServerInterface &socket); + + ProcessedResult get_destination_udp_mac(ServerInterface &socket) const; + + ProcessedResult set_destination_udp_ip(ServerInterface &socket); + + ProcessedResult get_destination_udp_ip(ServerInterface &socket) const; + + ProcessedResult set_destination_udp_port(ServerInterface &socket); + + ProcessedResult get_destination_udp_port(ServerInterface &socket) const; + + ProcessedResult get_num_frames(ServerInterface &socket) const; + + ProcessedResult set_num_frames(ServerInterface &socket); + + ProcessedResult get_num_triggers(ServerInterface &socket) const; + + ProcessedResult set_num_triggers(ServerInterface &socket); + + ProcessedResult get_version(ServerInterface &socket) const; + + ProcessedResult get_num_udp_interfaces(ServerInterface &socket) const; + + ProcessedResult get_detector_type(ServerInterface &socket) const; + + ProcessedResult get_receiver_parameters(ServerInterface &socket) const; + + ProcessedResult get_run_status(ServerInterface &socket) const; + + ProcessedResult initial_checks(ServerInterface &socket) const; + + ProcessedResult + set_module_position_and_update_srcudpmac(ServerInterface &socket); +}; + +template +DetectorServer::DetectorServer( + std::unique_ptr< + DetectorServerImpl::value>> + impl_, + uint16_t port) + : impl(std::move(impl_)) { + validatePortNumber(port); + + std::function fn = + [this](const detFuncs &function_id, ServerInterface &socket) { + return this->processFunction(function_id, socket); + }; + + tcpInterface = std::make_unique(fn, port); +} + +template +ProcessedResult DetectorServer::processFunction( + const detFuncs function_id, ServerInterface &socket) { + + switch (function_id) { + case detFuncs::F_GET_SERVER_VERSION: + return get_version(socket); + case detFuncs::F_GET_DETECTOR_TYPE: + return get_detector_type(socket); + case detFuncs::F_INITIAL_CHECKS: + return initial_checks(socket); + case detFuncs::F_GET_NUM_INTERFACES: + return get_num_udp_interfaces(socket); + case detFuncs::F_GET_UPDATE_MODE: + return get_update_mode(socket); + case detFuncs::F_SET_SOURCE_UDP_MAC: + return set_source_udp_mac(socket); + case detFuncs::F_GET_SOURCE_UDP_MAC: + return get_source_udp_mac(socket); + case detFuncs::F_SET_SOURCE_UDP_IP: + return set_source_udp_ip(socket); + case detFuncs::F_GET_SOURCE_UDP_IP: + return get_source_udp_ip(socket); + case detFuncs::F_SET_DEST_UDP_MAC: + return set_destination_udp_mac(socket); + case detFuncs::F_GET_DEST_UDP_MAC: + return get_destination_udp_mac(socket); + case detFuncs::F_SET_DEST_UDP_IP: + return set_destination_udp_ip(socket); + case detFuncs::F_GET_DEST_UDP_IP: + return get_destination_udp_ip(socket); + case detFuncs::F_SET_DEST_UDP_PORT: + return set_destination_udp_port(socket); + case detFuncs::F_GET_DEST_UDP_PORT: + return get_destination_udp_port(socket); + case detFuncs::F_GET_RUN_STATUS: + return get_run_status(socket); + case detFuncs::F_GET_NUM_FRAMES: + return get_num_frames(socket); + case detFuncs::F_SET_NUM_FRAMES: + return set_num_frames(socket); + case detFuncs::F_GET_NUM_TRIGGERS: + return get_num_triggers(socket); + case detFuncs::F_SET_NUM_TRIGGERS: + return set_num_triggers(socket); + case detFuncs::F_GET_RECEIVER_PARAMETERS: + return get_receiver_parameters(socket); + case detFuncs::F_SET_POSITION: + return set_module_position_and_update_srcudpmac(socket); + default: + LOG(logDEBUG) << "Checking specific server functions for function ID: " + << function_id; + // process detector specific functions + return getDerived()->processFunction(function_id, socket); + } + + return return_fail("Function not implemented"); +} + +template +ProcessedResult DetectorServer::get_update_mode( + ServerInterface &socket) const { + + const bool updateMode = impl->get_update_mode(); + + // TODO: catch the socket error during Send and add error message to the + // ProcessedResult but DatSocket shared with receiver - some refactoring + return send_result(socket, static_cast(updateMode)); +} + +template +ProcessedResult DetectorServer::get_source_udp_mac( + ServerInterface &socket) const { + auto srcUdpMac = impl->get_source_udp_mac(); + + return send_result(socket, srcUdpMac); +} + +template +ProcessedResult DetectorServer::set_source_udp_mac( + ServerInterface &socket) { + + uint64_t newsrcudpMac; + + try { + (void)socket.Receive(newsrcudpMac); + } catch (const SocketError &e) { + LOG(logERROR) << "Failed to receive new source UDP MAC address: " + << e.what(); + return return_fail("Failed to receive new source UDP MAC address: " + + std::string(e.what())); + } + + try { + getImpl()->set_source_udp_mac(newsrcudpMac); + } catch (const std::exception &e) { + LOG(logERROR) << "Failed to set source UDP MAC address: " << e.what(); + return_fail("Failed to set source UDP MAC address: " + + std::string(e.what())); + } + + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::set_source_udp_ip( + ServerInterface &socket) { + + uint32_t newSrcIp; + + try { + (void)socket.Receive(newSrcIp); + } catch (const SocketError &e) { + auto error_message = "Failed to receive new source UDP IP address: " + + std::string(e.what()); + LOG(logERROR) << error_message; + + return return_fail(error_message); + } + + impl->set_source_udp_ip(newSrcIp); + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::get_source_udp_ip( + ServerInterface &socket) const { + uint32_t src_UdpIp = impl->get_source_udp_ip(); + return send_result(socket, src_UdpIp); +} + +template +ProcessedResult DetectorServer::set_destination_udp_mac( + ServerInterface &socket) { + uint64_t newDstMac; + + try { + (void)socket.Receive(newDstMac); + } catch (const SocketError &e) { + auto error_message = + "Failed to receive new destination UDP MAC address: " + + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + + impl->set_destination_udp_mac(newDstMac); + + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::get_destination_udp_mac( + ServerInterface &socket) const { + + auto dstUdpMac = impl->get_destination_udp_mac(); + return send_result(socket, dstUdpMac); +} + +template +ProcessedResult DetectorServer::set_destination_udp_ip( + ServerInterface &socket) { + uint32_t newDstIp; + + try { + (void)socket.Receive(newDstIp); + } catch (const SocketError &e) { + auto error_message = + "Failed to receive new destination UDP IP address: " + + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + + impl->set_destination_udp_ip(newDstIp); + + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::get_destination_udp_ip( + ServerInterface &socket) const { + + uint32_t dstUdpIp = impl->get_destination_udp_ip(); + return send_result(socket, dstUdpIp); +} + +template +ProcessedResult DetectorServer::set_destination_udp_port( + ServerInterface &socket) { + uint16_t newDstPort; + + try { + (void)socket.Receive(newDstPort); + } catch (const SocketError &e) { + auto error_message = + "Failed to receive new destination UDP port number: " + + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + + impl->set_destination_udp_port(newDstPort); + + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::get_destination_udp_port( + ServerInterface &socket) const { + uint16_t dstUdpPort = impl->get_destination_udp_port(); + return send_result(socket, dstUdpPort); +}; + +template +ProcessedResult DetectorServer::get_num_frames( + ServerInterface &socket) const { + uint64_t num_frames{}; + try { + num_frames = getImpl()->get_num_frames(); + } catch (const std::exception &e) { + auto error_message = + "Failed to get number of frames: " + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + return send_result(socket, num_frames); +} + +template +ProcessedResult +DetectorServer::set_num_frames(ServerInterface &socket) { + int64_t num_frames{}; + try { + (void)socket.Receive(num_frames); + } catch (const SocketError &e) { + auto error_message = + "Failed to receive number of frames: " + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + try { + getImpl()->set_num_frames(num_frames); + } catch (const std::exception &e) { + auto error_message = + "Failed to set number of frames: " + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::get_num_triggers( + ServerInterface &socket) const { + uint64_t num_triggers{}; + try { + num_triggers = static_cast(getImpl()->get_num_triggers()); + } catch (const std::exception &e) { + auto error_message = + "Failed to get number of triggers: " + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + return send_result(socket, num_triggers); +} + +template +ProcessedResult DetectorServer::set_num_triggers( + ServerInterface &socket) { + int64_t num_triggers{}; + try { + (void)socket.Receive(num_triggers); + } catch (const SocketError &e) { + auto error_message = + "Failed to receive number of triggers: " + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + try { + getImpl()->set_num_triggers(num_triggers); + } catch (const std::exception &e) { + auto error_message = + "Failed to set number of triggers: " + std::string(e.what()); + LOG(logERROR) << error_message; + return return_fail(error_message); + } + return send_ok(socket); +} + +template +ProcessedResult DetectorServer::get_version( + ServerInterface &socket) const { + + auto version = + getImpl()->get_server_version(); // TODO: get Impl from derived server + + char version_cstr[MAX_STR_LENGTH]{}; + std::snprintf(version_cstr, sizeof(version_cstr), "%s", + version.c_str()); // ensures temination + LOG(TLogLevel::logDEBUG) << "Server Version: " << version; + return send_result( + socket, + version_cstr); // TODO: check what would be possible return codes!!! +} + +template +ProcessedResult DetectorServer::get_num_udp_interfaces( + ServerInterface &socket) const { + int num_udp_interfaces = getImpl()->get_num_udp_interfaces(); + + return send_result(socket, num_udp_interfaces); +} + +template +ProcessedResult DetectorServer::get_detector_type( + ServerInterface &socket) const { + uint32_t detectortype = getImpl()->get_detector_type(); + return send_result(socket, detectortype); +} + +template +ProcessedResult DetectorServer::get_receiver_parameters( + ServerInterface &socket) const { + + slsDetectorDefs::rxParameters rx_params = + getImpl()->get_receiver_parameters(); + + return send_result(socket, rx_params); +} + +template +ProcessedResult DetectorServer::get_run_status( + ServerInterface &socket) const { + + slsDetectorDefs::runStatus status = getImpl()->get_run_status(); + + return send_result(socket, status); +} + +template +ProcessedResult DetectorServer::initial_checks( + ServerInterface &socket) const { + auto detectorsetupstatus = getImpl()->get_detector_setup_status(); + + // TODO: should there be a time limit? + while (detectorsetupstatus.setup_status == + detector_setup_status::NOT_SETUP) { + std::this_thread::sleep_for(std::chrono::seconds(1)); + detectorsetupstatus = getImpl()->get_detector_setup_status(); + } + if (detectorsetupstatus.setup_status == + detector_setup_status::FAILED_SETUP) { + return return_fail("Initial checks failed: " + + detectorsetupstatus.error_message); + } else { + return send_result(socket, true); + } +} + +template +ProcessedResult +DetectorServer::set_module_position_and_update_srcudpmac( + ServerInterface &socket) { + + std::array position_info{}; // [num_modules_in_y, module_index] + try { + (void)socket.Receive(position_info.data(), + position_info.size() * sizeof(int)); + } catch (const SocketError &e) { + LOG(logERROR) + << "Failed to receive num modules in y dimension and module index: " + << e.what(); + return_fail( + "Failed to receive num modules in y dimension and module index: " + + std::string(e.what())); + } + + try { + getImpl()->set_module_position_and_update_srcudpmac(position_info); + } catch (const std::exception &e) { + return_fail("Failed to set module position: " + std::string(e.what())); + } + + return send_ok(socket); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServerImpl.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServerImpl.hpp new file mode 100644 index 000000000..8c4c29adf --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/DetectorServerImpl.hpp @@ -0,0 +1,109 @@ +#pragma once +#include "sls/SharedMemory.h" +#include +#include + +namespace sls { + +// TODO move to defs? +/// @brief struct saving udp details (one UDP port per module) +struct UDPInfo { + uint16_t srcport{}; + uint16_t dstport{}; + uint64_t srcmac{}; + uint64_t dstmac{}; + uint32_t srcip{}; + uint32_t dstip{}; +}; + +/// @brief struct to store detector setup status +struct detector_setup_status { + + enum SETUP_STATUS : uint8_t { + FAILED_SETUP = 0, + SUCCESSFUL_SETUP = 1, + NOT_SETUP = 2 + }; + + /// @brief true if setupDetector() was successful, false otherwise + SETUP_STATUS setup_status{NOT_SETUP}; + /// @brief error message if setupDetector() failed, empty otherwise + std::string error_message{}; +}; + +/// @brief Shared memory structure for stop server to store run status +struct acquisitionStatus { + + /* FIXED PATTERN FOR STATIC FUNCTIONS. DO NOT CHANGE, ONLY APPEND ------*/ + int shmversion; + + bool isValid{true}; // false if freed to block access from python or c++ api + + std::atomic scanStatus{ + slsDetectorDefs::runStatus::IDLE}; // idle, running or error + std::atomic scanStop{false}; + + // TODO: only neccessary for virtual, maybe have two shared memory + // structures, one for virtual + std::atomic status{ + slsDetectorDefs::runStatus::IDLE}; + std::atomic stop{false}; +}; + +template class DetectorServerImpl { + + public: + DetectorServerImpl(); + ~DetectorServerImpl(); + + bool get_update_mode() const; + + uint64_t get_source_udp_mac() const; + + void set_source_udp_ip(const uint32_t srcip); + + uint32_t get_source_udp_ip() const; + + void set_destination_udp_ip(const uint32_t dstip); + + uint32_t get_destination_udp_ip() const; + + void set_destination_udp_mac(const uint64_t dstmac); + + uint64_t get_destination_udp_mac() const; + + void set_destination_udp_port(const uint16_t dstport); + + uint16_t get_destination_udp_port() const; + + detector_setup_status get_detector_setup_status() const; + + protected: + std::array + udpDetails{}; // TODO: for now only one receiver per module + + /// @brief TODO what is this? + bool updateMode{ + false}; // what should the default be - can update module size etc. + + /// @brief shared mempory with aquisition status + mutable SharedMemory shm{ + 0, 0}; // TODO: is mutable really neccessary? + + /// @brief sets source UDP MAC address in udpDetails and updates udp + /// header + /// @param srcmac + void updateSrcMacAddress(const uint64_t srcmac); + + /// @brief true if setupDetector() was successful, false otherwise + detector_setup_status detectorSetupStatus{}; + + /// @brief true if the derived server is a stop server, false otherwise + static constexpr bool stop_server = isStopServer; + + private: + /// @brief creates and maps shared memory + void createSharedMemory(); +}; + +} // namespace sls diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/MemoryModel.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/MemoryModel.hpp new file mode 100644 index 000000000..8acc16a4e --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/MemoryModel.hpp @@ -0,0 +1,68 @@ +#pragma once +#include "fmt/format.h" +#include "sls/logger.h" +#include "sls/sls_detector_exceptions.h" +#include +#include + +namespace sls { + +/// @brief class to handle memory mapping and access for hardware IP cores +class HardwareMemoryModel { + + public: + HardwareMemoryModel(const uint32_t IPcore_base_address, + const size_t size_memory_space_); + + ~HardwareMemoryModel(); + + void mapToMemory(); + + void unmapMemory(); + + volatile uint32_t *getMappedMemoryPtr() const; + + private: + volatile uint32_t *mapped_memory_ptr{nullptr}; + + /// @brief offset of the IP core base address in the memory space, used for + /// mapping + const size_t IPCore_base_address{0}; + + /// @brief size mapped memory region [bytes] + const size_t size_memory_space{0}; +}; + +/// @brief class to handle memory mapping and access for virtual IP cores (e.g. +/// use software implementation of memory) +template class VirtualMemoryModel { + + public: + // IPcore_base_address is not used for virtual memory model but kept for + // compatibility with HardwareMemoryModel interface + VirtualMemoryModel(const uint32_t IPcore_base_address, + const size_t size_memory_space_) + : size_memory_space(size_memory_space_) { + (void)IPcore_base_address; // suppress unused parameter warning + } + + ~VirtualMemoryModel() = default; + + void mapToMemory() { + mapped_memory.resize( + size_memory_space / + sizeof(DataType)); // TODO: should it be zero initialized? + } + + DataType *getMappedMemoryPtr() { return mapped_memory.data(); } + + const DataType *getMappedMemoryPtr() const { return mapped_memory.data(); } + + private: + std::vector mapped_memory{}; + + /// @brief size mapped memory region [bytes] + const size_t size_memory_space{0}; +}; + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/RegisterHelperStructs.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/RegisterHelperStructs.hpp new file mode 100644 index 000000000..2c3265075 --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/RegisterHelperStructs.hpp @@ -0,0 +1,62 @@ +#pragma once +#include +#include +#include +#include + +namespace sls { + +enum class IPCore : uint32_t; // forward declaration of IPCore enum class + +/// @brief struct representing 32 bit register +struct Register { + /// @brief IP core address space + const IPCore ip_core{}; // TODO replace by enum type + + /// @brief Offset of the register in bytes from the base address of the IP + /// core + const uint32_t offset_in_bytes{}; +}; + +struct RegisterField { + /// @brief Register to which the field belongs + const Register register_{}; + + /// @brief Bit position of the least significant bit of the field in the + /// register + const uint32_t bit_position{}; + + /// @brief Bitmask for the field + const uint32_t bitmask{}; +}; + +// TODO: maybe static member function of RegisterField? +template +void setRegisterField(uint32_t ®istervalue, const RegisterField ®_field, + T field_value) { + + if (field_value > static_cast(reg_field.bitmask)) { + throw std::invalid_argument( + fmt::format("Value {} cannot fit in field with bitmask {}", + field_value, reg_field.bitmask)); + } + // Clear the bits corresponding to the field + registervalue &= ~(reg_field.bitmask << reg_field.bit_position); + // Set the new value for the field + registervalue |= (static_cast(field_value) & reg_field.bitmask) + << reg_field.bit_position; +} + +template +T getRegisterField(const uint32_t ®istervalue, + const RegisterField ®_field) { + // Extract the bits corresponding to the field and shift them to get the + // value + + auto field_value = + (registervalue >> reg_field.bit_position) & reg_field.bitmask; + + return static_cast(field_value); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/TCPInterface.h b/slsDetectorServers/slsDetectorServer_cpp/include/TCPInterface.hpp similarity index 50% rename from slsDetectorServers/slsDetectorServer_cpp/include/TCPInterface.h rename to slsDetectorServers/slsDetectorServer_cpp/include/TCPInterface.hpp index 6d3ea2c29..deb337e62 100644 --- a/slsDetectorServers/slsDetectorServer_cpp/include/TCPInterface.h +++ b/slsDetectorServers/slsDetectorServer_cpp/include/TCPInterface.hpp @@ -10,6 +10,31 @@ namespace sls { +using ReturnCode = slsDetectorDefs::ReturnCode; + +struct ProcessedResult { + /// @brief return code of the processed command + slsDetectorDefs::ReturnCode returnCode{}; + /// @brief error message to be sent to client in case of failure + std::string error_message{}; +}; + +// communication helpers +inline ProcessedResult return_fail(std::string_view error_message) { + return ProcessedResult{ReturnCode::FAIL, + static_cast(error_message)}; +} + +inline ProcessedResult send_ok(ServerInterface &socket) { + return ProcessedResult{ + static_cast(socket.Send(ReturnCode::OK))}; +} + +template +inline ProcessedResult send_result(ServerInterface &socket, const T &value) { + return ProcessedResult{static_cast(socket.sendResult(value))}; +} + /** * @brief TCPInterface class handles communication and processing of commands * from Client to Server. @@ -19,9 +44,10 @@ class TCPInterface { public: ~TCPInterface(); - TCPInterface(std::function &processFunction_, - const uint16_t portNumber = DEFAULT_TCP_CNTRL_PORTNO); + TCPInterface( + std::function + &processFunction_, + const uint16_t portNumber = DEFAULT_TCP_CNTRL_PORTNO); /// @brief creates tcp thread void startTCPServer(); @@ -40,12 +66,11 @@ class TCPInterface { * @param function_id The ID of the function recived by the server and to * be executed */ - slsDetectorDefs::ReturnCode processReceivedData(const detFuncs function_id, - ServerInterface &socket); + ProcessedResult processReceivedData(const detFuncs function_id, + ServerInterface &socket); /// @brief map of function IDs and corresponding functions - std::function + std::function processFunction; /// @brief TCP/IP port number for the detector server diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/helpers/Defs.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/helpers/Defs.hpp new file mode 100644 index 000000000..442a1df1d --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/helpers/Defs.hpp @@ -0,0 +1,19 @@ +/** @file Defs.hpp + * @brief this file contains some definitions used in the slsDetectorServer_cpp + * project. + */ +#pragma once +#include + +namespace sls { + +/// @brief Individual/Group bit offset in a 48 bit MAC address - 0 indicates +/// unicast mac address +constexpr uint8_t INDIVIDUAL_GROUP_BIT_OFFSET = 40; // 1000 0000 + +/// @brief Universal/Local bit offset in a 48 bit MAC address - 1 indicates +/// locally administered mac address, 0 indicates universally administered mac +/// address +constexpr uint8_t UNIVERSAL_LOCAL_BIT_OFFSET = 41; // 0100 0000 + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/helpers/Helpers.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/helpers/Helpers.hpp new file mode 100644 index 000000000..b17207003 --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/helpers/Helpers.hpp @@ -0,0 +1,64 @@ +#pragma once +#include "Defs.hpp" +#include "DetectorServerImpl.hpp" +#include "sls/SharedMemory.h" +#include "sls/sls_detector_defs.h" +#include +#include + +namespace sls { + +constexpr uint64_t mac_mask = 0xffffffffffff0000; +constexpr uint8_t offset_row_position_in_mac = 8; // given in bits +constexpr uint8_t offset_col_position_in_mac = 0; // given in bits + +/// @brief generates a random locally administered unicast MAC address for the +/// source UDP +/// @return generated MAC address +inline uint64_t generateRandomMacAddress() { + uint64_t mac = + 0xAA0000000000; // locally administered unicast address (0xA: 0b1010) // + // TODO maybe 0x02000000000 better? + for (int i = 2; i < 5; ++i) { + mac |= (static_cast(std::rand() % 256) << (i * 8)); + } + return mac; +} + +/// @brief generates a MAC address based on the module's row and column +/// position, last 32 bits of the MAC address are set to module_row and +/// module_col +/// @param module_row +/// @param module_col +/// @return generated MAC address +inline uint64_t generateMacAddressfromModulePosition(const uint8_t module_row, + const uint8_t module_col) { + + uint64_t newSrcMac = generateRandomMacAddress(); + newSrcMac = (newSrcMac & mac_mask) | + (module_row << offset_row_position_in_mac) | + (module_col << offset_col_position_in_mac); + + return newSrcMac; +} + +/// @brief check that mac is unicast and locally administered +/// @param mac +/// @return true if mac is valid, false otherwise +inline bool isValidMac(const uint64_t mac) { + if ((mac << INDIVIDUAL_GROUP_BIT_OFFSET) == 0 && + (mac << UNIVERSAL_LOCAL_BIT_OFFSET) == 1) { + return true; + } + return false; +} + +inline void freeSharedMemory() { + SharedMemory shm(0, -1, "server"); + + if (shm.exists()) { + shm.removeSharedMemory(); + } +} + +} // namespace sls diff --git a/slsDetectorServers/slsDetectorServer_cpp/include/helpers/type_traits.hpp b/slsDetectorServers/slsDetectorServer_cpp/include/helpers/type_traits.hpp new file mode 100644 index 000000000..97910cce1 --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/include/helpers/type_traits.hpp @@ -0,0 +1,57 @@ +#pragma once +#include + +namespace sls { + +// forward declares +template class MatterhornServer; + +template class VirtualMatterhornServer; + +template class MatterhornServerImpl; + +template class VirtualMatterhornServerImpl; + +template class BaseMatterhornServer; + +// type trait to get implementation type + +template struct implementation_type_trait; + +template +struct implementation_type_trait< + BaseMatterhornServer>> { + using ImplType = MatterhornServerImpl; +}; + +template +struct implementation_type_trait< + BaseMatterhornServer>> { + using ImplType = VirtualMatterhornServerImpl; +}; + +// type trait to get stop server flag from Detector Server + +template +struct is_stop_server : std::false_type {}; + +template <> +struct is_stop_server> : std::true_type {}; + +template <> +struct is_stop_server> : std::true_type {}; + +template <> +struct is_stop_server> : std::true_type {}; + +template <> struct is_stop_server> : std::true_type {}; + +template <> +struct is_stop_server>> + : std::true_type {}; + +template <> +struct is_stop_server>> + : std::true_type {}; + +} // namespace sls diff --git a/slsDetectorServers/slsDetectorServer_cpp/src/CommandLineOptions.cpp b/slsDetectorServers/slsDetectorServer_cpp/src/CommandLineOptions.cpp index 49d6a016b..1b0429c0a 100644 --- a/slsDetectorServers/slsDetectorServer_cpp/src/CommandLineOptions.cpp +++ b/slsDetectorServers/slsDetectorServer_cpp/src/CommandLineOptions.cpp @@ -1,4 +1,4 @@ -#include "CommandLineOptions.h" +#include "CommandLineOptions.hpp" #include "sls/ToString.h" #include "sls/sls_detector_exceptions.h" diff --git a/slsDetectorServers/slsDetectorServer_cpp/src/DetectorServerImpl.cpp b/slsDetectorServers/slsDetectorServer_cpp/src/DetectorServerImpl.cpp new file mode 100644 index 000000000..959fa2080 --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/src/DetectorServerImpl.cpp @@ -0,0 +1,117 @@ +#include "DetectorServerImpl.hpp" +#include "sls/logger.h" +#include "sls/sls_detector_exceptions.h" +#include + +namespace sls { + +template class DetectorServerImpl; // forward declare +template class DetectorServerImpl; // forward declare + +template +DetectorServerImpl::DetectorServerImpl() { + udpDetails[0].srcport = DEFAULT_UDP_SRC_PORTNO; + udpDetails[0].dstport = DEFAULT_UDP_DST_PORTNO; + + createSharedMemory(); +} + +template +DetectorServerImpl::~DetectorServerImpl() { + shm.removeSharedMemory(); +} + +template +void DetectorServerImpl::createSharedMemory() { + shm = SharedMemory(0, -1, "server"); + + if (shm.exists()) { + shm.openSharedMemory(true); // stop server + } else { + LOG(logINFOBLUE) << "Creating shared memory for acquisition status"; + try { + shm.createSharedMemory(); + } catch (const SharedMemoryAlreadyExistsError &e) { + shm.openSharedMemory(true); // potential race conditions between + // stop and control server + } + } +} + +template +void DetectorServerImpl::updateSrcMacAddress( + const uint64_t srcmac) { + LOG(logINFO) << "Updating source MAC address to: " + << fmt::format("{:02x}:{:02x}:{:02x}:{:02x}:{:02x}:{:02x}", + (srcmac >> 40) & 0xff, (srcmac >> 32) & 0xff, + (srcmac >> 24) & 0xff, (srcmac >> 16) & 0xff, + (srcmac >> 8) & 0xff, srcmac & 0xff); + + udpDetails[0].srcmac = srcmac; + + // TODO: update UDP header with new source MAC address + + // TODO: do i need to keep track of the configured member ? +} + +template +bool DetectorServerImpl::get_update_mode() const { + return updateMode; +} + +template +uint64_t DetectorServerImpl::get_source_udp_mac() const { + return udpDetails[0].srcmac; +} + +template +void DetectorServerImpl::set_source_udp_ip(const uint32_t srcip) { + udpDetails[0].srcip = srcip; +} + +template +uint32_t DetectorServerImpl::get_source_udp_ip() const { + return udpDetails[0].srcip; +} + +template +void DetectorServerImpl::set_destination_udp_ip( + const uint32_t dstip) { + udpDetails[0].dstip = dstip; +} + +template +uint32_t DetectorServerImpl::get_destination_udp_ip() const { + return udpDetails[0].dstip; +} + +template +void DetectorServerImpl::set_destination_udp_mac( + const uint64_t dstmac) { + // TODO: configuremac, check unicast address + udpDetails[0].dstmac = dstmac; +} + +template +uint64_t DetectorServerImpl::get_destination_udp_mac() const { + return udpDetails[0].dstmac; +} + +template +void DetectorServerImpl::set_destination_udp_port( + const uint16_t dstport) { + udpDetails[0].dstport = dstport; +} + +template +uint16_t DetectorServerImpl::get_destination_udp_port() const { + return udpDetails[0].dstport; +} + +template +detector_setup_status +DetectorServerImpl::get_detector_setup_status() const { + return detectorSetupStatus; +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/src/MemoryModel.cpp b/slsDetectorServers/slsDetectorServer_cpp/src/MemoryModel.cpp new file mode 100644 index 000000000..273002f2d --- /dev/null +++ b/slsDetectorServers/slsDetectorServer_cpp/src/MemoryModel.cpp @@ -0,0 +1,62 @@ +#include "MemoryModel.hpp" +#include +#include +#include +#include +#include +#include + +namespace sls { + +HardwareMemoryModel::HardwareMemoryModel(const uint32_t IPcore_base_address, + const size_t size_memory_space_) + : IPCore_base_address(IPcore_base_address), + size_memory_space(size_memory_space_) {} + +void HardwareMemoryModel::mapToMemory() { + + int fd = open("/dev/mem", O_RDWR | O_SYNC, 0); + + if (fd == -1) { + throw RuntimeError("Can't find /dev/mem"); + } + + auto void_mmap_ptr = + mmap(nullptr, size_memory_space, PROT_READ | PROT_WRITE, MAP_SHARED, fd, + IPCore_base_address); + + if (void_mmap_ptr == MAP_FAILED) { + throw RuntimeError( + fmt::format("Failed to map base address: {}", + IPCore_base_address)); // TODO: needs ToString + } + + mapped_memory_ptr = reinterpret_cast(void_mmap_ptr); + + close(fd); +} + +volatile uint32_t *HardwareMemoryModel::getMappedMemoryPtr() const { + return mapped_memory_ptr; +} + +void HardwareMemoryModel::unmapMemory() { + + if (mapped_memory_ptr != nullptr) { + if (munmap(reinterpret_cast( + const_cast(mapped_memory_ptr)), + size_memory_space) < 0) { + LOG(logWARNING) + << fmt::format("Failed to unmap memory for IP core: {}", + IPCore_base_address); // TODO: needs ToString + } + mapped_memory_ptr = nullptr; + } +} + +HardwareMemoryModel::~HardwareMemoryModel() { + LOG(logDEBUG1) << "HardwareMemoryModel destructor called, unmapping memory"; + unmapMemory(); +} + +} // namespace sls \ No newline at end of file diff --git a/slsDetectorServers/slsDetectorServer_cpp/src/TCPInterface.cpp b/slsDetectorServers/slsDetectorServer_cpp/src/TCPInterface.cpp index ea54d2f5a..2e7468060 100644 --- a/slsDetectorServers/slsDetectorServer_cpp/src/TCPInterface.cpp +++ b/slsDetectorServers/slsDetectorServer_cpp/src/TCPInterface.cpp @@ -1,4 +1,4 @@ -#include "TCPInterface.h" +#include "TCPInterface.hpp" #include "fmt/format.h" #include "sls/logger.h" @@ -8,8 +8,8 @@ namespace sls { TCPInterface::TCPInterface( - std::function &processFunction_, + std::function + &processFunction_, const uint16_t portNumber_) : processFunction(processFunction_), portNumber(portNumber_), server(portNumber_) { @@ -44,19 +44,23 @@ void TCPInterface::startTCPServerClientConnection() { auto socket = server.accept(); try { - socket.Receive(function_id); + (void)socket.Receive(function_id); if (function_id < 0 || function_id >= NUM_DET_FUNCTIONS) { throw RuntimeError(fmt::format( "{}:{}", UNRECOGNIZED_FNUM_ENUM, getFunctionNameFromEnum((enum detFuncs)function_id))); } - auto returncode = processReceivedData( + auto processedResult = processReceivedData( static_cast(function_id), socket); - if (returncode == slsDetectorDefs::ReturnCode::FAIL) { + // TODO: should technically fail before + if (processedResult.returnCode == + slsDetectorDefs::ReturnCode::FAIL) { throw RuntimeError(fmt::format( - "Error processing command with fnum: {}", - getFunctionNameFromEnum((enum detFuncs)function_id))); + "Error while processing command with fnum: {}, Error: " + "{}", + getFunctionNameFromEnum((enum detFuncs)function_id), + processedResult.error_message)); } } catch (const RuntimeError &e) { @@ -76,22 +80,20 @@ void TCPInterface::startTCPServerClientConnection() { LOG(logINFOBLUE) << "Exiting TCP Server"; } -slsDetectorDefs::ReturnCode -TCPInterface::processReceivedData(const detFuncs function_id, - ServerInterface &socket) { +ProcessedResult TCPInterface::processReceivedData(const detFuncs function_id, + ServerInterface &socket) { LOG(logDEBUG1) << "calling function fnum: " << function_id << " (" << getFunctionNameFromEnum((enum detFuncs)function_id) << ")"; - slsDetectorDefs::ReturnCode returncode = - processFunction(function_id, socket); + ProcessedResult processedResult = processFunction(function_id, socket); LOG(logDEBUG1) << "Function " << getFunctionNameFromEnum((enum detFuncs)function_id) << " finished"; - return returncode; + return processedResult; } } // namespace sls \ No newline at end of file diff --git a/slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh b/slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh index 0fdd93044..0b722d668 100644 --- a/slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh +++ b/slsDetectorSoftware/generator/autocomplete/bash_autocomplete.sh @@ -80,7 +80,7 @@ _sd() { local IS_PATH=0 -local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest include initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port power powerchip powerdac powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_streamdummyheader rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport " +local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest include initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port power powerchip powerdac powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_streamdummyheader rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_datastream udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport " __acquire() { FCN_RETURN="" return 0 @@ -600,23 +600,6 @@ fi fi return 0 } -__datastream() { -FCN_RETURN="" -if [[ ${IS_GET} -eq 1 ]]; then -if [[ "${cword}" == "2" ]]; then -FCN_RETURN="bottom left right top" -fi -fi -if [[ ${IS_GET} -eq 0 ]]; then -if [[ "${cword}" == "2" ]]; then -FCN_RETURN="bottom left right top" -fi -if [[ "${cword}" == "3" ]]; then -FCN_RETURN="0 1" -fi -fi -return 0 -} __dbitclk() { FCN_RETURN="" if [[ ${IS_GET} -eq 1 ]]; then @@ -2993,6 +2976,23 @@ __udp_cleardst() { FCN_RETURN="" return 0 } +__udp_datastream() { +FCN_RETURN="" +if [[ ${IS_GET} -eq 1 ]]; then +if [[ "${cword}" == "2" ]]; then +FCN_RETURN="bottom left right top" +fi +fi +if [[ ${IS_GET} -eq 0 ]]; then +if [[ "${cword}" == "2" ]]; then +FCN_RETURN="bottom left right top" +fi +if [[ "${cword}" == "3" ]]; then +FCN_RETURN="0 1" +fi +fi +return 0 +} __udp_dstip() { FCN_RETURN="" if [[ ${IS_GET} -eq 0 ]]; then diff --git a/slsDetectorSoftware/generator/autocomplete/dump.json b/slsDetectorSoftware/generator/autocomplete/dump.json deleted file mode 100644 index 3a804cf47..000000000 --- a/slsDetectorSoftware/generator/autocomplete/dump.json +++ /dev/null @@ -1,70937 +0,0 @@ -{ - "id": "0x564d8e36fb48", - "kind": "FunctionTemplateDecl", - "loc": { - "offset": 9063, - "file": "../include/sls/ToString.h", - "line": 283, - "col": 3, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9039, - "line": 282, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9904, - "line": 305, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "inner": [ - { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "loc": { - "offset": 9058, - "line": 282, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9049, - "col": 11, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9058, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "T", - "tagUsed": "typename", - "depth": 0, - "index": 0 - }, - { - "id": "0x564d8e36faa0", - "kind": "FunctionDecl", - "loc": { - "offset": 9063, - "line": 283, - "col": 3, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9061, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9904, - "line": 305, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "type": { - "qualType": "T (const std::string &, const std::string &)" - }, - "inner": [ - { - "id": "0x564d8e36f8c8", - "kind": "ParmVarDecl", - "loc": { - "offset": 9091, - "line": 283, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9072, - "col": 12, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9091, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "t", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "loc": { - "offset": 9113, - "col": 53, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9094, - "col": 34, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9113, - "col": 53, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "unit", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e3a49e8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9119, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9904, - "line": 305, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36fd70", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9125, - "line": 284, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9139, - "col": 19, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "loc": { - "offset": 9132, - "col": 12, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9125, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9138, - "col": 18, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "tval", - "type": { - "qualType": "double" - }, - "init": "list", - "inner": [ - { - "id": "0x564d8e36fd10", - "kind": "InitListExpr", - "range": { - "begin": { - "offset": 9136, - "col": 16, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9138, - "col": 18, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e36fd50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "prvalue", - "castKind": "IntegralToFloating", - "inner": [ - { - "id": "0x564d8e36fc98", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3702a8", - "kind": "CXXTryStmt", - "range": { - "begin": { - "offset": 9145, - "line": 285, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9295, - "line": 289, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36ff58", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9149, - "line": 285, - "col": 9, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9184, - "line": 287, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36ff38", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 9159, - "line": 286, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9177, - "col": 27, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "opcode": "=", - "inner": [ - { - "id": "0x564d8e36fd88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9159, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9159, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - }, - { - "id": "0x564d8e36fee8", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9166, - "col": 16, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9177, - "col": 27, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e36fed0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9166, - "col": 16, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9171, - "col": 21, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double (*)(const string &, size_t *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e36fe38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9166, - "col": 16, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9171, - "col": 21, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double (const string &, size_t *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6ca7f8", - "kind": "FunctionDecl", - "name": "stod", - "type": { - "qualType": "double (const string &, size_t *)" - } - } - } - ] - }, - { - "id": "0x564d8e36fe18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9176, - "col": 26, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9176, - "col": 26, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f8c8", - "kind": "ParmVarDecl", - "name": "t", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e36ff18", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8d6ca728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 159105, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 4489, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 159105, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8d6ca708", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 159105, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 159105, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e370288", - "kind": "CXXCatchStmt", - "range": { - "begin": { - "offset": 9186, - "file": "../include/sls/ToString.h", - "line": 287, - "col": 7, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9295, - "line": 289, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e370028", - "kind": "VarDecl", - "loc": { - "offset": 9222, - "line": 287, - "col": 43, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9193, - "col": 14, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9222, - "col": 43, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "e", - "type": { - "qualType": "const std::invalid_argument &" - } - }, - { - "id": "0x564d8e370270", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9225, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9295, - "line": 289, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e370258", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 9235, - "line": 288, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e370240", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 9235, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e370218", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9241, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e3701f8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 9241, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e3701f0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e3701c0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9241, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e370178", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e370100", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[33]" - }, - "valueCategory": "lvalue", - "value": "\"Could not convert string to time\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e370380", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9302, - "line": 291, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9329, - "col": 32, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3702d8", - "kind": "UsingDecl", - "loc": { - "offset": 9321, - "col": 24, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9302, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9321, - "col": 24, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "std::chrono::duration" - } - ] - }, - { - "id": "0x564d8e370450", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9335, - "line": 292, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9367, - "col": 37, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3703a8", - "kind": "UsingDecl", - "loc": { - "offset": 9354, - "col": 24, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9335, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9354, - "col": 24, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "std::chrono::duration_cast" - } - ] - }, - { - "id": "0x564d8e3a49b8", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9373, - "line": 293, - "col": 5, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e3717c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9377, - "line": 293, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e3717a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e371788", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e370468", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9377, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9377, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e371770", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e370488", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"ns\"" - } - ] - } - ] - }, - { - "id": "0x564d8e384d38", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9391, - "col": 23, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9465, - "line": 295, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e384d28", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9401, - "line": 294, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9458, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e384d00", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9408, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9458, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e371820", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9408, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9423, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e384cd8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9425, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9457, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e384980", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e384ca8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9425, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9457, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e384ad0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e371b00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4988", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9472, - "line": 295, - "col": 12, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e3860b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9476, - "line": 295, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e386098", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e386078", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e384d50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9476, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9476, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e386060", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e384d70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"us\"" - } - ] - } - ] - }, - { - "id": "0x564d8e38f5c8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9490, - "col": 30, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9565, - "line": 297, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e38f5b8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9500, - "line": 296, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9558, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e38f590", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9507, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9558, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3860f8", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9507, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9522, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e38f568", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9524, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9557, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e38f210", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e38f538", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9524, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9557, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e38f360", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3863c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4958", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9572, - "line": 297, - "col": 12, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e390940", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9576, - "line": 297, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e390928", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e390908", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e38f5e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9576, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9576, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e3908f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e38f600", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"ms\"" - } - ] - } - ] - }, - { - "id": "0x564d8e399e38", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9590, - "col": 30, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9665, - "line": 299, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e399e28", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9600, - "line": 298, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9658, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e399e00", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9607, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9658, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e390988", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9607, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9622, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e399dd8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9624, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9657, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e399a80", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e399da8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9624, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9657, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e399bd0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e390c50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4928", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9672, - "line": 299, - "col": 12, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e39b290", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 9676, - "line": 299, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9702, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e39b1b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9676, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e39b198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e39b178", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e399e50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9676, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9676, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e39b160", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e399e70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"s\"" - } - ] - } - ] - }, - { - "id": "0x564d8e39b238", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9702, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e39b208", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9696, - "col": 36, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "empty", - "isArrow": false, - "referencedMemberDecl": "0x564d8d69dff8", - "inner": [ - { - "id": "0x564d8e39b1e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4758", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9705, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9781, - "line": 301, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a4748", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9715, - "line": 300, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9774, - "col": 68, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a4720", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9722, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9774, - "col": 68, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e39b2c0", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9722, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9737, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e3a46f8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9739, - "col": 33, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9773, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::chrono::duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e3a43a0", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e3a46c8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9739, - "col": 33, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9773, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::chrono::duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e3a44f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e39b570", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4910", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9788, - "line": 301, - "col": 12, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a48f8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 9798, - "line": 302, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e3a48e0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 9798, - "line": 302, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3a48b8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9804, - "line": 302, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e3a4898", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 9804, - "line": 302, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e3a4890", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e3a4860", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9804, - "line": 302, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e3a4848", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e3a47b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[64]" - }, - "valueCategory": "lvalue", - "value": "\"Invalid unit in conversion from string to std::chrono::duration\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e3a4cc8", - "kind": "FunctionTemplateDecl", - "loc": { - "offset": 9931, - "file": "../include/sls/ToString.h", - "line": 307, - "col": 25, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9907, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10056, - "line": 311, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "inner": [ - { - "id": "0x564d8e3a4a20", - "kind": "TemplateTypeParmDecl", - "loc": { - "offset": 9926, - "line": 307, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9917, - "col": 11, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9926, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "T", - "tagUsed": "typename", - "depth": 0, - "index": 0 - }, - { - "id": "0x564d8e3a4c20", - "kind": "FunctionDecl", - "loc": { - "offset": 9931, - "col": 25, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9929, - "col": 23, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10056, - "line": 311, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "type": { - "qualType": "T (const std::string &)" - }, - "inner": [ - { - "id": "0x564d8e3a4b18", - "kind": "ParmVarDecl", - "loc": { - "offset": 9959, - "line": 307, - "col": 53, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9940, - "col": 34, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9959, - "col": 53, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "t", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e3a5bd8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9962, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10056, - "line": 311, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a57b0", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9968, - "line": 308, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9986, - "col": 23, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a4de8", - "kind": "VarDecl", - "loc": { - "offset": 9980, - "col": 17, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9968, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9985, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "tmp", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "init": "list", - "inner": [ - { - "id": "0x564d8e3a5780", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9980, - "col": 17, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9985, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const basic_string &)" - }, - "list": true, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e3a4e50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9984, - "col": 21, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9984, - "col": 21, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a4b18", - "kind": "ParmVarDecl", - "name": "t", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a5a98", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9992, - "line": 309, - "col": 5, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10019, - "col": 32, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a57e0", - "kind": "VarDecl", - "loc": { - "offset": 9997, - "col": 10, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9992, - "col": 5, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "unit", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3a5a80", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e3a5978", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e3a5970", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e3a5948", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3a5930", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::string (*)(std::string &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3a58b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::string (std::string &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8ddb34e0", - "kind": "FunctionDecl", - "name": "RemoveUnit", - "type": { - "qualType": "std::string (std::string &)" - } - } - } - ] - }, - { - "id": "0x564d8e3a5890", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10015, - "col": 28, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10015, - "col": 28, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a4de8", - "kind": "VarDecl", - "name": "tmp", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a5bc8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 10025, - "line": 310, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10053, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a5b98", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 10032, - "col": 12, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10053, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3a5ad8", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 10032, - "col": 12, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10042, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "StringTo", - "lookups": [ - { - "id": "0x564d8e3a4cc8", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - }, - { - "id": "0x564d8e36fb48", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e3a4a70", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e3a4a20", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e3a5b58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10044, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10044, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a4de8", - "kind": "VarDecl", - "name": "tmp", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - }, - { - "id": "0x564d8e3a5b78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10049, - "col": 29, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10049, - "col": 29, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a57e0", - "kind": "VarDecl", - "name": "unit", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e6e5410", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::detectorType (const std::string &)" - } - }, - { - "id": "0x564d8e6effb0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::detectorSettings (const std::string &)" - } - }, - { - "id": "0x564d8e709dc0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::speedLevel (const std::string &)" - } - }, - { - "id": "0x564d8e714930", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::timingMode (const std::string &)" - } - }, - { - "id": "0x564d8e71b800", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::frameDiscardPolicy (const std::string &)" - } - }, - { - "id": "0x564d8e71fea0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::fileFormat (const std::string &)" - } - }, - { - "id": "0x564d8e7230b0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::externalSignalFlag (const std::string &)" - } - }, - { - "id": "0x564d8e728b60", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::readoutMode (const std::string &)" - } - }, - { - "id": "0x564d8e72fa60", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::dacIndex (const std::string &)" - } - }, - { - "id": "0x564d8e7b5a50", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::powerIndex (const std::string &)" - } - }, - { - "id": "0x564d8e7bdd60", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::burstMode (const std::string &)" - } - }, - { - "id": "0x564d8e7c37f0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::timingSourceType (const std::string &)" - } - }, - { - "id": "0x564d8e7c6a40", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::M3_GainCaps (const std::string &)" - } - }, - { - "id": "0x564d8e7ced30", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::portPosition (const std::string &)" - } - }, - { - "id": "0x564d8e7d47b0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::streamingInterface (const std::string &)" - } - }, - { - "id": "0x564d8e7da5c0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::vetoAlgorithm (const std::string &)" - } - }, - { - "id": "0x564d8e7dd7f0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::gainMode (const std::string &)" - } - }, - { - "id": "0x564d8e7e5ae0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::polarity (const std::string &)" - } - }, - { - "id": "0x564d8e7e8cf0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::timingInfoDecoder (const std::string &)" - } - }, - { - "id": "0x564d8e7ebf40", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::collectionMode (const std::string &)" - } - }, - { - "id": "0x564d8e3acd20", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "RegisterAddress (const std::string &)" - } - }, - { - "id": "0x564d8e3ad230", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "RegisterValue (const std::string &)" - } - }, - { - "id": "0x564d8e7ef130", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint8_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f42a0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint16_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f6320", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint32_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f7390", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint64_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f8408", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "int (const std::string &)" - } - }, - { - "id": "0x564d8e7f9410", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "bool (const std::string &)" - } - }, - { - "id": "0x564d8e7ff890", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "int64_t (const std::string &)" - } - } - ] -} -{ - "id": "0x564d8e3a5dd0", - "kind": "FunctionDecl", - "loc": { - "offset": 10090, - "file": "../include/sls/ToString.h", - "line": 313, - "col": 32, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10059, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10119, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a6040", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12detectorTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "inner": [ - { - "id": "0x564d8dc74900", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "decl": { - "id": "0x564d8dc74860", - "kind": "EnumDecl", - "name": "detectorType" - } - } - ] - }, - { - "id": "0x564d8e3a5cb0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10118, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10099, - "col": 41, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10118, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a6360", - "kind": "FunctionDecl", - "loc": { - "offset": 10157, - "file": "../include/sls/ToString.h", - "line": 314, - "col": 36, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10122, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10186, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a65d0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16detectorSettingsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorSettings (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "inner": [ - { - "id": "0x564d8dd58ab0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "decl": { - "id": "0x564d8dd58a08", - "kind": "EnumDecl", - "name": "detectorSettings" - } - } - ] - }, - { - "id": "0x564d8e3a6240", - "kind": "ParmVarDecl", - "loc": { - "offset": 10185, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10166, - "col": 45, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10185, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a68f0", - "kind": "FunctionDecl", - "loc": { - "offset": 10218, - "file": "../include/sls/ToString.h", - "line": 315, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10189, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10247, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a6b60", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10speedLevelEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::speedLevel (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "inner": [ - { - "id": "0x564d8dd59860", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "decl": { - "id": "0x564d8dd597b8", - "kind": "EnumDecl", - "name": "speedLevel" - } - } - ] - }, - { - "id": "0x564d8e3a67d0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10246, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10227, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10246, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a6e80", - "kind": "FunctionDecl", - "loc": { - "offset": 10279, - "file": "../include/sls/ToString.h", - "line": 316, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10250, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10308, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a70f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10timingModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "inner": [ - { - "id": "0x564d8dd56080", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "decl": { - "id": "0x564d8dd55fd8", - "kind": "EnumDecl", - "name": "timingMode" - } - } - ] - }, - { - "id": "0x564d8e3a6d60", - "kind": "ParmVarDecl", - "loc": { - "offset": 10307, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10288, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10307, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a7410", - "kind": "FunctionDecl", - "loc": { - "offset": 10348, - "file": "../include/sls/ToString.h", - "line": 317, - "col": 38, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10311, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10377, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a7680", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18frameDiscardPolicyEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::frameDiscardPolicy (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "inner": [ - { - "id": "0x564d8dd540b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "decl": { - "id": "0x564d8dd54008", - "kind": "EnumDecl", - "name": "frameDiscardPolicy" - } - } - ] - }, - { - "id": "0x564d8e3a72f0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10376, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10357, - "col": 47, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10376, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a79a0", - "kind": "FunctionDecl", - "loc": { - "offset": 10409, - "file": "../include/sls/ToString.h", - "line": 318, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10380, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10438, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a7c10", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10fileFormatEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::fileFormat (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "inner": [ - { - "id": "0x564d8dd542d0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "decl": { - "id": "0x564d8dd54230", - "kind": "EnumDecl", - "name": "fileFormat" - } - } - ] - }, - { - "id": "0x564d8e3a7880", - "kind": "ParmVarDecl", - "loc": { - "offset": 10437, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10418, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10437, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a7f30", - "kind": "FunctionDecl", - "loc": { - "offset": 10478, - "file": "../include/sls/ToString.h", - "line": 319, - "col": 38, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10441, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10507, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a81a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18externalSignalFlagEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::externalSignalFlag (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "inner": [ - { - "id": "0x564d8dd55e30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "decl": { - "id": "0x564d8dd55d88", - "kind": "EnumDecl", - "name": "externalSignalFlag" - } - } - ] - }, - { - "id": "0x564d8e3a7e10", - "kind": "ParmVarDecl", - "loc": { - "offset": 10506, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10487, - "col": 47, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10506, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a84c0", - "kind": "FunctionDecl", - "loc": { - "offset": 10540, - "file": "../include/sls/ToString.h", - "line": 320, - "col": 31, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10510, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10569, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a8730", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11readoutModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::readoutMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "inner": [ - { - "id": "0x564d8dd595b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "decl": { - "id": "0x564d8dd59508", - "kind": "EnumDecl", - "name": "readoutMode" - } - } - ] - }, - { - "id": "0x564d8e3a83a0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10568, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10549, - "col": 40, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10568, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a8a50", - "kind": "FunctionDecl", - "loc": { - "offset": 10599, - "file": "../include/sls/ToString.h", - "line": 321, - "col": 28, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10572, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10628, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a8cc0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8dacIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::dacIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "inner": [ - { - "id": "0x564d8dd56380", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "decl": { - "id": "0x564d8dd562d8", - "kind": "EnumDecl", - "name": "dacIndex" - } - } - ] - }, - { - "id": "0x564d8e3a8930", - "kind": "ParmVarDecl", - "loc": { - "offset": 10627, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10608, - "col": 37, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10627, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a8fe0", - "kind": "FunctionDecl", - "loc": { - "offset": 10660, - "file": "../include/sls/ToString.h", - "line": 322, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10631, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10689, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a9250", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10powerIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::powerIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "inner": [ - { - "id": "0x564d8dd585f0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "decl": { - "id": "0x564d8dd58550", - "kind": "EnumDecl", - "name": "powerIndex" - } - } - ] - }, - { - "id": "0x564d8e3a8ec0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10688, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10669, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10688, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a9570", - "kind": "FunctionDecl", - "loc": { - "offset": 10720, - "file": "../include/sls/ToString.h", - "line": 323, - "col": 29, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10692, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10749, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a9840", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs9burstModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::burstMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "inner": [ - { - "id": "0x564d8dd59b10", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "decl": { - "id": "0x564d8dd59a68", - "kind": "EnumDecl", - "name": "burstMode" - } - } - ] - }, - { - "id": "0x564d8e3a9450", - "kind": "ParmVarDecl", - "loc": { - "offset": 10748, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10729, - "col": 38, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10748, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3a9b60", - "kind": "FunctionDecl", - "loc": { - "offset": 10787, - "file": "../include/sls/ToString.h", - "line": 324, - "col": 36, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10752, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10816, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a9dd0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16timingSourceTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingSourceType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "inner": [ - { - "id": "0x564d8dd59dc0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "decl": { - "id": "0x564d8dd59d18", - "kind": "EnumDecl", - "name": "timingSourceType" - } - } - ] - }, - { - "id": "0x564d8e3a9a40", - "kind": "ParmVarDecl", - "loc": { - "offset": 10815, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10796, - "col": 45, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10815, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3aa0f0", - "kind": "FunctionDecl", - "loc": { - "offset": 10849, - "file": "../include/sls/ToString.h", - "line": 325, - "col": 31, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10819, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10878, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aa360", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11M3_GainCapsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::M3_GainCaps (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "inner": [ - { - "id": "0x564d8dd59f30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "decl": { - "id": "0x564d8dd59e90", - "kind": "EnumDecl", - "name": "M3_GainCaps" - } - } - ] - }, - { - "id": "0x564d8e3a9fd0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10877, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10858, - "col": 40, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10877, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3aa680", - "kind": "FunctionDecl", - "loc": { - "offset": 10912, - "file": "../include/sls/ToString.h", - "line": 326, - "col": 32, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10881, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10941, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aa8f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12portPositionEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::portPosition (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "inner": [ - { - "id": "0x564d8dd5a590", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "decl": { - "id": "0x564d8dd5a4f0", - "kind": "EnumDecl", - "name": "portPosition" - } - } - ] - }, - { - "id": "0x564d8e3aa560", - "kind": "ParmVarDecl", - "loc": { - "offset": 10940, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10921, - "col": 41, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10940, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3aac10", - "kind": "FunctionDecl", - "loc": { - "offset": 10981, - "file": "../include/sls/ToString.h", - "line": 327, - "col": 38, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10944, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11010, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aae80", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18streamingInterfaceEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::streamingInterface (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "inner": [ - { - "id": "0x564d8dd5a950", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "decl": { - "id": "0x564d8dd5a8b0", - "kind": "EnumDecl", - "name": "streamingInterface" - } - } - ] - }, - { - "id": "0x564d8e3aaaf0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11009, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10990, - "col": 47, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11009, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ab1a0", - "kind": "FunctionDecl", - "loc": { - "offset": 11045, - "file": "../include/sls/ToString.h", - "line": 328, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11013, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11074, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ab410", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs13vetoAlgorithmEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::vetoAlgorithm (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "inner": [ - { - "id": "0x564d8dd5ad30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "decl": { - "id": "0x564d8dd5ac90", - "kind": "EnumDecl", - "name": "vetoAlgorithm" - } - } - ] - }, - { - "id": "0x564d8e3ab080", - "kind": "ParmVarDecl", - "loc": { - "offset": 11073, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11054, - "col": 42, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11073, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ab730", - "kind": "FunctionDecl", - "loc": { - "offset": 11104, - "file": "../include/sls/ToString.h", - "line": 329, - "col": 28, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11077, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11133, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ab9a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8gainModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::gainMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "inner": [ - { - "id": "0x564d8dd5aea0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "decl": { - "id": "0x564d8dd5ae00", - "kind": "EnumDecl", - "name": "gainMode" - } - } - ] - }, - { - "id": "0x564d8e3ab610", - "kind": "ParmVarDecl", - "loc": { - "offset": 11132, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11113, - "col": 37, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11132, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3abcc0", - "kind": "FunctionDecl", - "loc": { - "offset": 11163, - "file": "../include/sls/ToString.h", - "line": 330, - "col": 28, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11136, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11192, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3abf30", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8polarityEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::polarity (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "inner": [ - { - "id": "0x564d8dd5b170", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "decl": { - "id": "0x564d8dd5b0d0", - "kind": "EnumDecl", - "name": "polarity" - } - } - ] - }, - { - "id": "0x564d8e3abba0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11191, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11172, - "col": 37, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11191, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ac250", - "kind": "FunctionDecl", - "loc": { - "offset": 11231, - "file": "../include/sls/ToString.h", - "line": 331, - "col": 37, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11195, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11260, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ac4c0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs17timingInfoDecoderEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingInfoDecoder (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "inner": [ - { - "id": "0x564d8dd5b2e0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "decl": { - "id": "0x564d8dd5b240", - "kind": "EnumDecl", - "name": "timingInfoDecoder" - } - } - ] - }, - { - "id": "0x564d8e3ac130", - "kind": "ParmVarDecl", - "loc": { - "offset": 11259, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11240, - "col": 46, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11259, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ac7e0", - "kind": "FunctionDecl", - "loc": { - "offset": 11296, - "file": "../include/sls/ToString.h", - "line": 332, - "col": 34, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11263, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11325, - "col": 63, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aca50", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs14collectionModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::collectionMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "inner": [ - { - "id": "0x564d8dd5b450", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "decl": { - "id": "0x564d8dd5b3b0", - "kind": "EnumDecl", - "name": "collectionMode" - } - } - ] - }, - { - "id": "0x564d8e3ac6c0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11324, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11305, - "col": 43, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11324, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3acd20", - "kind": "FunctionDecl", - "loc": { - "offset": 11356, - "file": "../include/sls/ToString.h", - "line": 333, - "col": 29, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11328, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11385, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3acf60", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToINS_15RegisterAddressEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "RegisterAddress (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "sls::RegisterAddress" - }, - "inner": [ - { - "id": "0x564d8d8f3f60", - "kind": "RecordType", - "type": { - "qualType": "sls::RegisterAddress" - }, - "decl": { - "id": "0x564d8d8f3ed0", - "kind": "CXXRecordDecl", - "name": "RegisterAddress" - } - } - ] - }, - { - "id": "0x564d8e3acc10", - "kind": "ParmVarDecl", - "loc": { - "offset": 11384, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11365, - "col": 38, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11384, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ad230", - "kind": "FunctionDecl", - "loc": { - "offset": 11414, - "file": "../include/sls/ToString.h", - "line": 334, - "col": 27, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11388, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11443, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ad470", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToINS_13RegisterValueEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "RegisterValue (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "sls::RegisterValue" - }, - "inner": [ - { - "id": "0x564d8d8f7650", - "kind": "RecordType", - "type": { - "qualType": "sls::RegisterValue" - }, - "decl": { - "id": "0x564d8d8f75c0", - "kind": "CXXRecordDecl", - "name": "RegisterValue" - } - } - ] - }, - { - "id": "0x564d8e3ad120", - "kind": "ParmVarDecl", - "loc": { - "offset": 11442, - "col": 55, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11423, - "col": 36, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11442, - "col": 55, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ad740", - "kind": "FunctionDecl", - "loc": { - "offset": 11467, - "file": "../include/sls/ToString.h", - "line": 336, - "col": 21, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11447, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11496, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ad980", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIhEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint8_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned char" - }, - "inner": [ - { - "id": "0x564d8c93dc50", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned char" - } - } - ] - }, - { - "id": "0x564d8e3ad630", - "kind": "ParmVarDecl", - "loc": { - "offset": 11495, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11476, - "col": 30, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11495, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3adc50", - "kind": "FunctionDecl", - "loc": { - "offset": 11520, - "file": "../include/sls/ToString.h", - "line": 337, - "col": 22, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11499, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11549, - "col": 51, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ade90", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToItEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint16_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned short" - }, - "inner": [ - { - "id": "0x564d8c93dc70", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned short" - } - } - ] - }, - { - "id": "0x564d8e3adb40", - "kind": "ParmVarDecl", - "loc": { - "offset": 11548, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11529, - "col": 31, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11548, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ae160", - "kind": "FunctionDecl", - "loc": { - "offset": 11573, - "file": "../include/sls/ToString.h", - "line": 338, - "col": 22, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11552, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11602, - "col": 51, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ae3a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIjEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint32_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned int" - }, - "inner": [ - { - "id": "0x564d8c93dc90", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned int" - } - } - ] - }, - { - "id": "0x564d8e3ae050", - "kind": "ParmVarDecl", - "loc": { - "offset": 11601, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11582, - "col": 31, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11601, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3ae630", - "kind": "FunctionDecl", - "loc": { - "offset": 11626, - "file": "../include/sls/ToString.h", - "line": 339, - "col": 22, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11605, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11655, - "col": 51, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ae870", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToImEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned long" - }, - "inner": [ - { - "id": "0x564d8c93dcb0", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned long" - } - } - ] - }, - { - "id": "0x564d8e3ae560", - "kind": "ParmVarDecl", - "loc": { - "offset": 11654, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11635, - "col": 31, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11654, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3aeb48", - "kind": "FunctionDecl", - "loc": { - "offset": 11674, - "file": "../include/sls/ToString.h", - "line": 340, - "col": 17, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11658, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11703, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aed90", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIiEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "int" - }, - "inner": [ - { - "id": "0x564d8c93dbf0", - "kind": "BuiltinType", - "type": { - "qualType": "int" - } - } - ] - }, - { - "id": "0x564d8e3aea30", - "kind": "ParmVarDecl", - "loc": { - "offset": 11702, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11683, - "col": 26, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11702, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3af020", - "kind": "FunctionDecl", - "loc": { - "offset": 11723, - "file": "../include/sls/ToString.h", - "line": 341, - "col": 18, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11706, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11752, - "col": 47, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3af260", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIbEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "bool (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "bool" - }, - "inner": [ - { - "id": "0x564d8c93db70", - "kind": "BuiltinType", - "type": { - "qualType": "bool" - } - } - ] - }, - { - "id": "0x564d8e3aef50", - "kind": "ParmVarDecl", - "loc": { - "offset": 11751, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11732, - "col": 27, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11751, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3af5f0", - "kind": "FunctionDecl", - "loc": { - "offset": 11760, - "file": "../include/sls/ToString.h", - "line": 342, - "col": 6, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11755, - "col": 1, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11814, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isUsed": true, - "name": "StringTo", - "mangledName": "_ZN3sls8StringToERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN15slsDetectorDefs10boolFormatE", - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - }, - "inner": [ - { - "id": "0x564d8e3af408", - "kind": "ParmVarDecl", - "loc": { - "offset": 11788, - "col": 34, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11769, - "col": 15, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11788, - "col": 34, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e3af4d0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11808, - "col": 54, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11791, - "col": 37, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11808, - "col": 54, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "format", - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - } - } - ] -} -{ - "id": "0x564d8e3af830", - "kind": "FunctionDecl", - "loc": { - "offset": 11837, - "file": "../include/sls/ToString.h", - "line": 343, - "col": 21, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11817, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11866, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3afa70", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "long" - }, - "inner": [ - { - "id": "0x564d8c93dc10", - "kind": "BuiltinType", - "type": { - "qualType": "long" - } - } - ] - }, - { - "id": "0x564d8e3af728", - "kind": "ParmVarDecl", - "loc": { - "offset": 11865, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11846, - "col": 30, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11865, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -} -{ - "id": "0x564d8e3b0a28", - "kind": "FunctionTemplateDecl", - "loc": { - "offset": 12103, - "file": "../include/sls/ToString.h", - "line": 353, - "col": 16, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12066, - "line": 352, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12313, - "line": 359, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "inner": [ - { - "id": "0x564d8e3b03b0", - "kind": "TemplateTypeParmDecl", - "loc": { - "offset": 12085, - "line": 352, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12076, - "col": 11, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12085, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "T", - "tagUsed": "typename", - "depth": 0, - "index": 0 - }, - { - "id": "0x564d8e3b0980", - "kind": "FunctionDecl", - "loc": { - "offset": 12103, - "line": 353, - "col": 16, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12088, - "col": 1, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12313, - "line": 359, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "type": { - "qualType": "std::vector (const std::vector &)" - }, - "inner": [ - { - "id": "0x564d8e3b0858", - "kind": "ParmVarDecl", - "loc": { - "offset": 12144, - "line": 353, - "col": 57, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12112, - "col": 25, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12144, - "col": 57, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "strings", - "type": { - "qualType": "const std::vector &" - } - }, - { - "id": "0x564d8e3e1eb0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 12153, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12313, - "line": 359, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3b0d20", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12159, - "line": 354, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12180, - "col": 26, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "loc": { - "offset": 12174, - "col": 20, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12159, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12174, - "col": 20, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "nrvo": true - } - ] - }, - { - "id": "0x564d8e3da3e0", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 12186, - "line": 355, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12215, - "col": 34, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3b0d58", - "kind": "CXXDependentScopeMemberExpr", - "range": { - "begin": { - "offset": 12186, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12193, - "col": 12, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "isArrow": false, - "member": "reserve", - "inner": [ - { - "id": "0x564d8e3b0d38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12186, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12186, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - } - } - } - ] - }, - { - "id": "0x564d8e3d9eb8", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12214, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d0a5778" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3d9e88", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12209, - "col": 28, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "size", - "isArrow": false, - "referencedMemberDecl": "0x564d8e3ce890", - "inner": [ - { - "id": "0x564d8e3b0da0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0858", - "kind": "ParmVarDecl", - "name": "strings", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1c88", - "kind": "CXXForRangeStmt", - "range": { - "begin": { - "offset": 12222, - "line": 356, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12291, - "line": 357, - "col": 40, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - {}, - { - "id": "0x564d8e3da718", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12243, - "line": 356, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da520", - "kind": "VarDecl", - "loc": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isImplicit": true, - "isReferenced": true, - "name": "__range2", - "type": { - "qualType": "const std::vector &" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3da408", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0858", - "kind": "ParmVarDecl", - "name": "strings", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e3de940", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "loc": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isImplicit": true, - "isReferenced": true, - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3da900", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3da8d0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "begin", - "isArrow": false, - "referencedMemberDecl": "0x564d8e3cd938", - "inner": [ - { - "id": "0x564d8e3da730", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da520", - "kind": "VarDecl", - "name": "__range2", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3de958", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da808", - "kind": "VarDecl", - "loc": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isImplicit": true, - "isReferenced": true, - "name": "__end2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3de860", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3de830", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "end", - "isArrow": false, - "referencedMemberDecl": "0x564d8e3cdbc8", - "inner": [ - { - "id": "0x564d8e3da750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da520", - "kind": "VarDecl", - "name": "__range2", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1758", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e3e1740", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &, const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &) noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3e1390", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &, const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &) noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3df528", - "kind": "FunctionDecl", - "name": "operator!=", - "type": { - "qualType": "bool (const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &, const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &) noexcept" - } - } - } - ] - }, - { - "id": "0x564d8e3e1360", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const __gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3de970", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - }, - { - "id": "0x564d8e3e1378", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const __gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3de990", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da808", - "kind": "VarDecl", - "name": "__end2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e3e18f8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "__normal_iterator *, vector>>" - }, - "valueCategory": "lvalue", - "inner": [ - { - "id": "0x564d8e3e18e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "__normal_iterator *, vector>> &(*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3e17b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "__normal_iterator *, vector>> &() noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3dd280", - "kind": "CXXMethodDecl", - "name": "operator++", - "type": { - "qualType": "__normal_iterator *, vector>> &() noexcept" - } - } - } - ] - }, - { - "id": "0x564d8e3e1790", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - }, - { - "id": "0x564d8e3da4e8", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12227, - "col": 10, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12250, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da480", - "kind": "VarDecl", - "loc": { - "offset": 12239, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12227, - "col": 10, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "s", - "type": { - "qualType": "std::basic_string const &" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3e1ac8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const std::basic_string" - }, - "valueCategory": "lvalue", - "inner": [ - { - "id": "0x564d8e3e1ab0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "reference (*)() const noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3e1998", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "reference () const noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3dce18", - "kind": "CXXMethodDecl", - "name": "operator*", - "type": { - "qualType": "reference () const noexcept" - } - } - } - ] - }, - { - "id": "0x564d8e3e1980", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const __gnu_cxx::__normal_iterator *, std::vector>>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3e1960", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1e50", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 12260, - "line": 357, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12291, - "col": 40, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3e1d08", - "kind": "CXXDependentScopeMemberExpr", - "range": { - "begin": { - "offset": 12260, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12267, - "col": 16, - "tokLen": 9, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "isArrow": false, - "member": "push_back", - "inner": [ - { - "id": "0x564d8e3e1ce8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12260, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12260, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - } - } - } - ] - }, - { - "id": "0x564d8e3e1e28", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 12277, - "col": 26, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12290, - "col": 39, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3e1d80", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 12277, - "col": 26, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12287, - "col": 36, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "StringTo", - "lookups": [ - { - "id": "0x564d8e3b0a28", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - }, - { - "id": "0x564d8e36fb48", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - }, - { - "id": "0x564d8e3a4cc8", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e3b0400", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e3b03b0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e3e1e08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12289, - "col": 38, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12289, - "col": 38, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "std::basic_string const" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da480", - "kind": "VarDecl", - "name": "s", - "type": { - "qualType": "std::basic_string const &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1e98", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 12298, - "line": 358, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12305, - "col": 12, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3e1e78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12305, - "col": 12, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12305, - "col": 12, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - } - } - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e6e5410", - "kind": "FunctionDecl", - "loc": { - "offset": 22683, - "file": "ToString.cpp", - "line": 742, - "col": 32, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 22652, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 23242, - "line": 760, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a5dd0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12detectorTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "inner": [ - { - "id": "0x564d8dc74900", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "decl": { - "id": "0x564d8dc74860", - "kind": "EnumDecl", - "name": "detectorType" - } - } - ] - }, - { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "loc": { - "offset": 22711, - "line": 742, - "col": 60, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 22692, - "col": 41, - "tokLen": 5 - }, - "end": { - "offset": 22711, - "col": 60, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e6efdd0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 22714, - "col": 63, - "tokLen": 1 - }, - "end": { - "offset": 23242, - "line": 760, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e6e6a00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22720, - "line": 743, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22759, - "line": 744, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e6e6950", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22724, - "line": 743, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22729, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6e6938", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22726, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22726, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e6918", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22726, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22726, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e55f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22724, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22724, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6e6900", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22729, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 22729, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e5618", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22729, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 22729, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"Eiger\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6e69f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22746, - "line": 744, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22759, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e6e69c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22753, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22759, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74978", - "kind": "EnumConstantDecl", - "name": "EIGER", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6e7e30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22770, - "line": 745, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22812, - "line": 746, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e7d80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22774, - "line": 745, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22779, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6e7d68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e7d48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e6a20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22774, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22774, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6e7d30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22779, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22779, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e6a40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22779, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22779, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"Gotthard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6e7e20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22799, - "line": 746, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22812, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e7df0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22806, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22812, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc749f8", - "kind": "EnumConstantDecl", - "name": "GOTTHARD", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6e9260", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22826, - "line": 747, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22868, - "line": 748, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e91b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22830, - "line": 747, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22835, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6e9198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22832, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22832, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e9178", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22832, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22832, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e7e50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22830, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22830, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6e9160", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22835, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22835, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e7e70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22835, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22835, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"Jungfrau\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6e9250", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22855, - "line": 748, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22868, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e9220", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22862, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22868, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74a50", - "kind": "EnumConstantDecl", - "name": "JUNGFRAU", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ea690", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22882, - "line": 749, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22929, - "line": 750, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e6ea5e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22886, - "line": 749, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22891, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ea5c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22888, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22888, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ea5a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22888, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22888, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e9280", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22886, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22886, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ea590", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22891, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 22891, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e92a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22891, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 22891, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"ChipTestBoard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ea680", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22916, - "line": 750, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22929, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e6ea650", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22923, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22929, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74aa8", - "kind": "EnumConstantDecl", - "name": "CHIPTESTBOARD", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ebac0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22948, - "line": 751, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22988, - "line": 752, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e6eba10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22952, - "line": 751, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22957, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6eb9f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22954, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22954, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6eb9d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22954, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22954, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ea6b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22952, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22952, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6eb9c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22957, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 22957, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ea6d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22957, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 22957, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"Moench\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ebab0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22975, - "line": 752, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22988, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e6eba80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22982, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22988, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74b00", - "kind": "EnumConstantDecl", - "name": "MOENCH", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ecef0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23000, - "line": 753, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23041, - "line": 754, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6ece40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23004, - "line": 753, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23009, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ece28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23006, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23006, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ece08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23006, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23006, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ebae0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23004, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23004, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ecdf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23009, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23009, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ebb00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23009, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23009, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"Mythen3\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ecee0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23028, - "line": 754, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23041, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6eceb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23035, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23041, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74b58", - "kind": "EnumConstantDecl", - "name": "MYTHEN3", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ee320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23054, - "line": 755, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23097, - "line": 756, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6ee270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23058, - "line": 755, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23063, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ee258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23060, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23060, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ee238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23060, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23060, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ecf10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23058, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23058, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ee220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23063, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23063, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ecf30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23063, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23063, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"Gotthard2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ee310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23084, - "line": 756, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23097, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6ee2e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23091, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23097, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74bb0", - "kind": "EnumConstantDecl", - "name": "GOTTHARD2", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ef790", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23112, - "line": 757, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23166, - "line": 758, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e6ef6e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23116, - "line": 757, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23121, - "col": 14, - "tokLen": 22 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ef6c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ef6a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ee340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23116, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23116, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ef690", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23121, - "col": 14, - "tokLen": 22 - }, - "end": { - "offset": 23121, - "col": 14, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ee360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23121, - "col": 14, - "tokLen": 22 - }, - "end": { - "offset": 23121, - "col": 14, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Xilinx_ChipTestBoard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ef780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23153, - "line": 758, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23166, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e6ef750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23160, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23166, - "col": 22, - "tokLen": 20 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74c08", - "kind": "EnumConstantDecl", - "name": "XILINX_CHIPTESTBOARD", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6efdb8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 23192, - "line": 759, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e6efda0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 23192, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e6efd78", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 23198, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e6efd58", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 23198, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e6efd50", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e6efd20", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 23198, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e6efd08", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e6efcf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e6efcd0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e6efcc8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e6efc90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6efc78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23236, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 23236, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6efc58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23236, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 23236, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e6efc40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23211, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ef7c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23211, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown detector type \"" - } - ] - }, - { - "id": "0x564d8e6ef7f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23238, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e6effb0", - "kind": "FunctionDecl", - "loc": { - "offset": 23280, - "file": "ToString.cpp", - "line": 762, - "col": 36, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 23245, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 24529, - "line": 804, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a6360", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16detectorSettingsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorSettings (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "inner": [ - { - "id": "0x564d8dd58ab0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "decl": { - "id": "0x564d8dd58a08", - "kind": "EnumDecl", - "name": "detectorSettings" - } - } - ] - }, - { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "loc": { - "offset": 23308, - "line": 762, - "col": 64, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 23289, - "col": 45, - "tokLen": 5 - }, - "end": { - "offset": 23308, - "col": 64, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e709b78", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 23311, - "col": 67, - "tokLen": 1 - }, - "end": { - "offset": 24529, - "line": 804, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e6f15a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23317, - "line": 763, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23359, - "line": 764, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f14f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23321, - "line": 763, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23326, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f14d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23323, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23323, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f14b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23323, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23323, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f0198", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23321, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23321, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f14a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23326, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23326, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f01b8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23326, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23326, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"standard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f1590", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23346, - "line": 764, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23359, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f1560", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23353, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23359, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ad0", - "kind": "EnumConstantDecl", - "name": "STANDARD", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f29d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23373, - "line": 765, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23411, - "line": 766, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e6f2920", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23377, - "line": 765, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23382, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f2908", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23379, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23379, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f28e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23379, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23379, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f15c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23377, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23377, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f28d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23382, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 23382, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f15e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23382, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 23382, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"fast\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f29c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23398, - "line": 766, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23411, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e6f2990", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23405, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23411, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58b28", - "kind": "EnumConstantDecl", - "name": "FAST", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f3e00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23421, - "line": 767, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23463, - "line": 768, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f3d50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23425, - "line": 767, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23430, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f3d38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23427, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23427, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f3d18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23427, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23427, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f29f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23425, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23425, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f3d00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23430, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23430, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f2a10", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23430, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23430, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"highgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f3df0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23450, - "line": 768, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23463, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f3dc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23457, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23463, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58b80", - "kind": "EnumConstantDecl", - "name": "HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f5230", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23477, - "line": 769, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23522, - "line": 770, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6f5180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23481, - "line": 769, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23486, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f5168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f5148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f3e20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23481, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23481, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f5130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23486, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23486, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f3e40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23486, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23486, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"dynamicgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f5220", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23509, - "line": 770, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23522, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6f51f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23516, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23522, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58bd8", - "kind": "EnumConstantDecl", - "name": "DYNAMICGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f6660", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23539, - "line": 771, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23580, - "line": 772, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6f65b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23543, - "line": 771, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23548, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f6598", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23545, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23545, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f6578", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23545, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23545, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f5250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23543, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23543, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f6560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23548, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23548, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f5270", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23548, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23548, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"lowgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f6650", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23567, - "line": 772, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23580, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6f6620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23574, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23580, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58c30", - "kind": "EnumConstantDecl", - "name": "LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f7a90", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23593, - "line": 773, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23637, - "line": 774, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e6f79e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23597, - "line": 773, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23602, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f79c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23599, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23599, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f79a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23599, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23599, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f6680", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23597, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23597, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f7990", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23602, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 23602, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f66a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23602, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 23602, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"mediumgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f7a80", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23624, - "line": 774, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23637, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e6f7a50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23631, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23637, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58c88", - "kind": "EnumConstantDecl", - "name": "MEDIUMGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f8ec0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23653, - "line": 775, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23699, - "line": 776, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e6f8e10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23657, - "line": 775, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23662, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f8df8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23659, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23659, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f8dd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23659, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23659, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f7ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23657, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23657, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f8dc0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23662, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 23662, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f7ad0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23662, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 23662, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"veryhighgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f8eb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23686, - "line": 776, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23699, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e6f8e80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23693, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23699, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ce0", - "kind": "EnumConstantDecl", - "name": "VERYHIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fa2f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23717, - "line": 777, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23760, - "line": 778, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6fa240", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23721, - "line": 777, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23726, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fa228", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23723, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23723, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fa208", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23723, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23723, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f8ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23721, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23721, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fa1f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23726, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23726, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f8f00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23726, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23726, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"highgain0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fa2e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23747, - "line": 778, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23760, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6fa2b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23754, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23760, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58d38", - "kind": "EnumConstantDecl", - "name": "HIGHGAIN0", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fb730", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23775, - "line": 779, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23817, - "line": 780, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fb680", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23779, - "line": 779, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23784, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fb668", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23781, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23781, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fb648", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23781, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23781, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fa310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23779, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23779, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fb630", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23784, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23784, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fa330", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23784, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23784, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"fixgain1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fb720", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23804, - "line": 780, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23817, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fb6f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23811, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23817, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58d90", - "kind": "EnumConstantDecl", - "name": "FIXGAIN1", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fcb60", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23831, - "line": 781, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23873, - "line": 782, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fcab0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23835, - "line": 781, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23840, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fca98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23837, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23837, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fca78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23837, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23837, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fb750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23835, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23835, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fca60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23840, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23840, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fb770", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23840, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23840, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"fixgain2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fcb50", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23860, - "line": 782, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23873, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fcb20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23867, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23873, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58de8", - "kind": "EnumConstantDecl", - "name": "FIXGAIN2", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fdf90", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23887, - "line": 783, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23932, - "line": 784, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6fdee0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23891, - "line": 783, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23896, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fdec8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23893, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23893, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fdea8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23893, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23893, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fcb80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23891, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23891, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fde90", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23896, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23896, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fcba0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23896, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23896, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"verylowgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fdf80", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23919, - "line": 784, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23932, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6fdf50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23926, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23932, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58e40", - "kind": "EnumConstantDecl", - "name": "VERYLOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ff3c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23949, - "line": 785, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23988, - "line": 786, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6ff310", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23953, - "line": 785, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23958, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ff2f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23955, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23955, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ff2d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23955, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23955, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fdfb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23953, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23953, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ff2c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23958, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 23958, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fdfd0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23958, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 23958, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g1_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ff3b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23975, - "line": 786, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23988, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6ff380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23982, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23988, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58e98", - "kind": "EnumConstantDecl", - "name": "G1_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7007f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24005, - "line": 787, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24044, - "line": 788, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e700740", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24009, - "line": 787, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24014, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e700728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24011, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24011, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e700708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24011, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24011, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ff3e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24009, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24009, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7006f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24014, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24014, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ff400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24014, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24014, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g1_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7007e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24031, - "line": 788, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24044, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7007b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24038, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24044, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ef0", - "kind": "EnumConstantDecl", - "name": "G1_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e701c20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24060, - "line": 789, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24102, - "line": 790, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e701b70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24064, - "line": 789, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24069, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e701b58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24066, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24066, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e701b38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24066, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24066, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e700810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24064, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24064, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e701b20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24069, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24069, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e700830", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24069, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24069, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_hc_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e701c10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24089, - "line": 790, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24102, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e701be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24096, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24102, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58f48", - "kind": "EnumConstantDecl", - "name": "G2_HIGHCAP_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e703050", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24127, - "line": 791, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24169, - "line": 792, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e702fa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24131, - "line": 791, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24136, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e702f88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24133, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24133, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e702f68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24133, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24133, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e701c40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24131, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24131, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e702f50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24136, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24136, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e701c60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24136, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24136, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_hc_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e703040", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24156, - "line": 792, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24169, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e703010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24163, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24169, - "col": 22, - "tokLen": 18 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58fa0", - "kind": "EnumConstantDecl", - "name": "G2_HIGHCAP_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e704480", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24193, - "line": 793, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24235, - "line": 794, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e7043d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24197, - "line": 793, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24202, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7043b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24199, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24199, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e704398", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24199, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24199, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e703070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24197, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24197, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e704380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24202, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24202, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e703090", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24202, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24202, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_lc_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e704470", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24222, - "line": 794, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24235, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e704440", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24229, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24235, - "col": 22, - "tokLen": 18 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ff8", - "kind": "EnumConstantDecl", - "name": "G2_LOWCAP_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7058b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24259, - "line": 795, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24301, - "line": 796, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e705800", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24263, - "line": 795, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24268, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7057e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24265, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24265, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7057c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24265, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24265, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7044a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24263, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24263, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7057b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24268, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24268, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7044c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24268, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24268, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_lc_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7058a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24288, - "line": 796, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24301, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e705870", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24295, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24301, - "col": 22, - "tokLen": 17 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59050", - "kind": "EnumConstantDecl", - "name": "G2_LOWCAP_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e706ce0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24324, - "line": 797, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24363, - "line": 798, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e706c30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24328, - "line": 797, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24333, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e706c18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e706bf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7058d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24328, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24328, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e706be0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24333, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24333, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7058f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24333, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24333, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g4_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e706cd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24350, - "line": 798, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24363, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e706ca0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24357, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24363, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd590a8", - "kind": "EnumConstantDecl", - "name": "G4_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e708110", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24380, - "line": 799, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24419, - "line": 800, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e708060", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24384, - "line": 799, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24389, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e708048", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24386, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24386, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e708028", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24386, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24386, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e706d00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24384, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24384, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e708010", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24389, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24389, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e706d20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24389, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24389, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"gain0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e708100", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24406, - "line": 800, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24419, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7080d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24413, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24419, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59158", - "kind": "EnumConstantDecl", - "name": "GAIN0", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e709540", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24430, - "line": 801, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24469, - "line": 802, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e709490", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24434, - "line": 801, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24439, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e709478", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24436, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24436, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e709458", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24436, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24436, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e708130", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24434, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24434, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e709440", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24439, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24439, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e708150", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24439, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24439, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g4_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e709530", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24456, - "line": 802, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24469, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e709500", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24463, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24469, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59100", - "kind": "EnumConstantDecl", - "name": "G4_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e709b60", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 24485, - "line": 803, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e709b48", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 24485, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e709b20", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 24491, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e709b00", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 24491, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e709af8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e709ac8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 24491, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e709ab0", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e709a98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e709a78", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e709a70", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e709a38", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e709a20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24523, - "col": 43, - "tokLen": 1 - }, - "end": { - "offset": 24523, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e709a00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24523, - "col": 43, - "tokLen": 1 - }, - "end": { - "offset": 24523, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7099e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24504, - "col": 24, - "tokLen": 18 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e709570", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24504, - "col": 24, - "tokLen": 18 - } - }, - "type": { - "qualType": "const char[17]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown setting \"" - } - ] - }, - { - "id": "0x564d8e709598", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24525, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e709dc0", - "kind": "FunctionDecl", - "loc": { - "offset": 24561, - "file": "ToString.cpp", - "line": 806, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 24532, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 25086, - "line": 824, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a68f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10speedLevelEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::speedLevel (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "inner": [ - { - "id": "0x564d8dd59860", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "decl": { - "id": "0x564d8dd597b8", - "kind": "EnumDecl", - "name": "speedLevel" - } - } - ] - }, - { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "loc": { - "offset": 24589, - "line": 806, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 24570, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 24589, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e714748", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 24592, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 25086, - "line": 824, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e70b3c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24598, - "line": 807, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24642, - "line": 808, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70b310", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24602, - "line": 807, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24607, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70b2f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24604, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24604, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70b2d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24604, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24604, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e709fa8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24602, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24602, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70b2c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24607, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24607, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e709fc8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24607, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24607, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"full_speed\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70b3b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24629, - "line": 808, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24642, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70b380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24636, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24642, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59880", - "kind": "EnumConstantDecl", - "name": "FULL_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e70c7f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24658, - "line": 809, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24693, - "line": 810, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70c740", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24662, - "line": 809, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24667, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70c728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24664, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24664, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70c708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24664, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24664, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70b3e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24662, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24662, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70c6f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24667, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24667, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70b400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24667, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24667, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70c7e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24680, - "line": 810, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24693, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70c7b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24687, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24693, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59880", - "kind": "EnumConstantDecl", - "name": "FULL_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e70dc20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24709, - "line": 811, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24753, - "line": 812, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70db70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24713, - "line": 811, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24718, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70db58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24715, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24715, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70db38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24715, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24715, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70c810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24713, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24713, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70db20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24718, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24718, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70c830", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24718, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24718, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"half_speed\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70dc10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24740, - "line": 812, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24753, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70dbe0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24747, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24753, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd598d8", - "kind": "EnumConstantDecl", - "name": "HALF_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e70f050", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24769, - "line": 813, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24804, - "line": 814, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70efa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24773, - "line": 813, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24778, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70ef88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70ef68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70dc40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24773, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24773, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70ef50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24778, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24778, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70dc60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24778, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24778, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70f040", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24791, - "line": 814, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24804, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70f010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24798, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24804, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd598d8", - "kind": "EnumConstantDecl", - "name": "HALF_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e710480", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24820, - "line": 815, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24867, - "line": 816, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7103d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24824, - "line": 815, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24829, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7103b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24826, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24826, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e710398", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24826, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24826, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70f070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24824, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24824, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e710380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24829, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 24829, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70f090", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24829, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 24829, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"quarter_speed\"" - } - ] - } - ] - }, - { - "id": "0x564d8e710470", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24854, - "line": 816, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24867, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e710440", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24861, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24867, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59930", - "kind": "EnumConstantDecl", - "name": "QUARTER_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7118b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24886, - "line": 817, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24921, - "line": 818, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e711800", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24890, - "line": 817, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24895, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7117e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24892, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24892, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7117c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24892, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24892, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7104a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24890, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24890, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7117b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24895, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24895, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7104c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24895, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24895, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7118a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24908, - "line": 818, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24921, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e711870", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24915, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24921, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59930", - "kind": "EnumConstantDecl", - "name": "QUARTER_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e712ce0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24940, - "line": 819, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24977, - "line": 820, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e712c30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24944, - "line": 819, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24949, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e712c18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24946, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24946, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e712bf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24946, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24946, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7118d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24944, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24944, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e712be0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24949, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 24949, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7118f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24949, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 24949, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"108\"" - } - ] - } - ] - }, - { - "id": "0x564d8e712cd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24964, - "line": 820, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24977, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e712ca0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24971, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24977, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59988", - "kind": "EnumConstantDecl", - "name": "G2_108MHZ", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e714110", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24992, - "line": 821, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25029, - "line": 822, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e714060", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24996, - "line": 821, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25001, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e714048", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24998, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24998, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e714028", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24998, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24998, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e712d00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24996, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24996, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e714010", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25001, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 25001, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e712d20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25001, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 25001, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"144\"" - } - ] - } - ] - }, - { - "id": "0x564d8e714100", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25016, - "line": 822, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25029, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7140d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25023, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25029, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd599e0", - "kind": "EnumConstantDecl", - "name": "G2_144MHZ", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e714730", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 25044, - "line": 823, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e714718", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 25044, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7146f0", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 25050, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7146d0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25050, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7146c8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e714698", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 25050, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e714680", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e714668", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e714648", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e714640", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e714608", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7145f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25080, - "col": 41, - "tokLen": 1 - }, - "end": { - "offset": 25080, - "col": 41, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7145d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25080, - "col": 41, - "tokLen": 1 - }, - "end": { - "offset": 25080, - "col": 41, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7145b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25063, - "col": 24, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e714140", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25063, - "col": 24, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown speed \"" - } - ] - }, - { - "id": "0x564d8e714168", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25082, - "col": 43, - "tokLen": 1 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e714930", - "kind": "FunctionDecl", - "loc": { - "offset": 25118, - "file": "ToString.cpp", - "line": 826, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 25089, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 25505, - "line": 838, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a6e80", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10timingModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "inner": [ - { - "id": "0x564d8dd56080", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "decl": { - "id": "0x564d8dd55fd8", - "kind": "EnumDecl", - "name": "timingMode" - } - } - ] - }, - { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "loc": { - "offset": 25146, - "line": 826, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 25127, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 25146, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e71b630", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 25149, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 25505, - "line": 838, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e715f20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25155, - "line": 827, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25193, - "line": 828, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e715e70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25159, - "line": 827, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25164, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e715e58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25161, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25161, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e715e38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25161, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25161, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e714b18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25159, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25159, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e715e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25164, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25164, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e714b38", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25164, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25164, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"auto\"" - } - ] - } - ] - }, - { - "id": "0x564d8e715f10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25180, - "line": 828, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25193, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e715ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25187, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25193, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd560a0", - "kind": "EnumConstantDecl", - "name": "AUTO_TIMING", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e717350", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25210, - "line": 829, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25251, - "line": 830, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7172a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25214, - "line": 829, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25219, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e717288", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25216, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25216, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e717268", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25216, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25216, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e715f40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25214, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25214, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e717250", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25219, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 25219, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e715f60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25219, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 25219, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"trigger\"" - } - ] - } - ] - }, - { - "id": "0x564d8e717340", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25238, - "line": 830, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25251, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e717310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25245, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25251, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd560f8", - "kind": "EnumConstantDecl", - "name": "TRIGGER_EXPOSURE", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e718780", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25273, - "line": 831, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25313, - "line": 832, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7186d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25277, - "line": 831, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25282, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7186b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25279, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25279, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e718698", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25279, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25279, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e717370", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25277, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25277, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e718680", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25282, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25282, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e717390", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25282, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25282, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"gating\"" - } - ] - } - ] - }, - { - "id": "0x564d8e718770", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25300, - "line": 832, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25313, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e718740", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25307, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25313, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56150", - "kind": "EnumConstantDecl", - "name": "GATED", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e719bb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25324, - "line": 833, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25371, - "line": 834, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e719b00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25328, - "line": 833, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25333, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e719ae8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e719ac8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7187a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25328, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25328, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e719ab0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25333, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 25333, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7187c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25333, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 25333, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"burst_trigger\"" - } - ] - } - ] - }, - { - "id": "0x564d8e719ba0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25358, - "line": 834, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25371, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e719b70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25365, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25371, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd561a8", - "kind": "EnumConstantDecl", - "name": "BURST_TRIGGER", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71aff0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25390, - "line": 835, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25438, - "line": 836, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e71af40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25394, - "line": 835, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25399, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71af28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25396, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25396, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71af08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25396, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25396, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e719bd0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25394, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25394, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71aef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25399, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25399, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e719bf0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25399, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25399, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"trigger_gating\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71afe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25425, - "line": 836, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25438, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e71afb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25432, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25438, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56200", - "kind": "EnumConstantDecl", - "name": "TRIGGER_GATED", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71b618", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 25457, - "line": 837, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e71b600", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 25457, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e71b5d8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 25463, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e71b5b8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25463, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71b5b0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71b580", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 25463, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e71b568", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e71b550", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e71b530", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71b528", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71b4f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71b4d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25499, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 25499, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71b4b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25499, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 25499, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e71b4a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25476, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71b020", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25476, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown timing mode \"" - } - ] - }, - { - "id": "0x564d8e71b050", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25501, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e71b800", - "kind": "FunctionDecl", - "loc": { - "offset": 25545, - "file": "ToString.cpp", - "line": 840, - "col": 38, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 25508, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 25846, - "line": 848, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a7410", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18frameDiscardPolicyEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::frameDiscardPolicy (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "inner": [ - { - "id": "0x564d8dd540b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "decl": { - "id": "0x564d8dd54008", - "kind": "EnumDecl", - "name": "frameDiscardPolicy" - } - } - ] - }, - { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "loc": { - "offset": 25573, - "line": 840, - "col": 66, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 25554, - "col": 47, - "tokLen": 5 - }, - "end": { - "offset": 25573, - "col": 66, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e71fce0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 25576, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 25846, - "line": 848, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e71ce00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25582, - "line": 841, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25625, - "line": 842, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e71cd50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25586, - "line": 841, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25591, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71cd38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25588, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25588, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71cd18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25588, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25588, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e71b9e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25586, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25586, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71cd00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25591, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 25591, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71ba08", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25591, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 25591, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"nodiscard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71cdf0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25612, - "line": 842, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25625, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e71cdc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25619, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25625, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd540d0", - "kind": "EnumConstantDecl", - "name": "NO_DISCARD", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71e230", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25641, - "line": 843, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25687, - "line": 844, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e71e180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25645, - "line": 843, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25650, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71e168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25647, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25647, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71e148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25647, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25647, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e71ce20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25645, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25645, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71e130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25650, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 25650, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71ce40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25650, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 25650, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"discardempty\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71e220", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25674, - "line": 844, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25687, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e71e1f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25681, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25687, - "col": 22, - "tokLen": 20 - } - }, - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd54128", - "kind": "EnumConstantDecl", - "name": "DISCARD_EMPTY_FRAMES", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71f660", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25713, - "line": 845, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25761, - "line": 846, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e71f5b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25717, - "line": 845, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25722, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71f598", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25719, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25719, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71f578", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25719, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25719, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e71e250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25717, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25717, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71f560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25722, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25722, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71e270", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25722, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25722, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"discardpartial\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71f650", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25748, - "line": 846, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25761, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e71f620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25755, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25761, - "col": 22, - "tokLen": 22 - } - }, - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd54180", - "kind": "EnumConstantDecl", - "name": "DISCARD_PARTIAL_FRAMES", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71fcc8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 25789, - "line": 847, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e71fcb0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 25789, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e71fc88", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 25795, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e71fc68", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25795, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71fc60", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71fc30", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 25795, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e71fc18", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e71fc00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e71fbe0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71fbd8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71fba0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71fb88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25840, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 25840, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71fb68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25840, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 25840, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e71fb50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25808, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71f690", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25808, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char[30]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown frame discard policy \"" - } - ] - }, - { - "id": "0x564d8e71f6c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25842, - "col": 58, - "tokLen": 1 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e71fea0", - "kind": "FunctionDecl", - "loc": { - "offset": 25878, - "file": "ToString.cpp", - "line": 850, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 25849, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 26063, - "line": 856, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a79a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10fileFormatEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::fileFormat (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "inner": [ - { - "id": "0x564d8dd542d0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "decl": { - "id": "0x564d8dd54230", - "kind": "EnumDecl", - "name": "fileFormat" - } - } - ] - }, - { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "loc": { - "offset": 25906, - "line": 850, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 25887, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 25906, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e722f00", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 25909, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 26063, - "line": 856, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e721490", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25915, - "line": 851, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25953, - "line": 852, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7213e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25919, - "line": 851, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25924, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7213c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25921, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25921, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7213a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25921, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25921, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e720088", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25919, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25919, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e721390", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25924, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25924, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7200a8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25924, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25924, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"hdf5\"" - } - ] - } - ] - }, - { - "id": "0x564d8e721480", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25940, - "line": 852, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25953, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e721450", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25947, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25953, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd54348", - "kind": "EnumConstantDecl", - "name": "HDF5", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7228c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25963, - "line": 853, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26003, - "line": 854, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e722810", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25967, - "line": 853, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25972, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7227f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25969, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25969, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7227d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25969, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25969, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7214b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25967, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25967, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7227c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25972, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25972, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7214d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25972, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25972, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"binary\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7228b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25990, - "line": 854, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26003, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e722880", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25997, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26003, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd542f0", - "kind": "EnumConstantDecl", - "name": "BINARY", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e722ee8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 26015, - "line": 855, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e722ed0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 26015, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e722ea8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 26021, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e722e88", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26021, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e722e80", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e722e50", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 26021, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e722e38", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e722e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e722e00", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e722df8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e722dc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e722da8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26057, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 26057, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e722d88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26057, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 26057, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e722d70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26034, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7228f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26034, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown file format \"" - } - ] - }, - { - "id": "0x564d8e722920", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26059, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7230b0", - "kind": "FunctionDecl", - "loc": { - "offset": 26103, - "file": "ToString.cpp", - "line": 858, - "col": 38, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 26066, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 26497, - "line": 868, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a7f30", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18externalSignalFlagEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::externalSignalFlag (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "inner": [ - { - "id": "0x564d8dd55e30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "decl": { - "id": "0x564d8dd55d88", - "kind": "EnumDecl", - "name": "externalSignalFlag" - } - } - ] - }, - { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "loc": { - "offset": 26131, - "line": 858, - "col": 66, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 26112, - "col": 47, - "tokLen": 5 - }, - "end": { - "offset": 26131, - "col": 66, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e728998", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 26134, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 26497, - "line": 868, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7246b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26140, - "line": 859, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26196, - "line": 860, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e724600", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26144, - "line": 859, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26149, - "col": 14, - "tokLen": 24 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7245e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26146, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26146, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7245c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26146, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26146, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e723298", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26144, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26144, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7245b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26149, - "col": 14, - "tokLen": 24 - }, - "end": { - "offset": 26149, - "col": 14, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7232b8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26149, - "col": 14, - "tokLen": 24 - }, - "end": { - "offset": 26149, - "col": 14, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"trigger_in_rising_edge\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7246a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26183, - "line": 860, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26196, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e724670", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26190, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26196, - "col": 22, - "tokLen": 22 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55e50", - "kind": "EnumConstantDecl", - "name": "TRIGGER_IN_RISING_EDGE", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e725af0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26224, - "line": 861, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26281, - "line": 862, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e725a40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26228, - "line": 861, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26233, - "col": 14, - "tokLen": 25 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e725a28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26230, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26230, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e725a08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26230, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26230, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7246d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26228, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26228, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7259f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26233, - "col": 14, - "tokLen": 25 - }, - "end": { - "offset": 26233, - "col": 14, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7246f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26233, - "col": 14, - "tokLen": 25 - }, - "end": { - "offset": 26233, - "col": 14, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char[24]" - }, - "valueCategory": "lvalue", - "value": "\"trigger_in_falling_edge\"" - } - ] - } - ] - }, - { - "id": "0x564d8e725ae0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26268, - "line": 862, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26281, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e725ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26275, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26281, - "col": 22, - "tokLen": 23 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55ea8", - "kind": "EnumConstantDecl", - "name": "TRIGGER_IN_FALLING_EDGE", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e726f20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26310, - "line": 863, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26356, - "line": 864, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e726e70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26314, - "line": 863, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26319, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e726e58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26316, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26316, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e726e38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26316, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26316, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e725b10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26314, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26314, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e726e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26319, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 26319, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e725b30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26319, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 26319, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"inversion_on\"" - } - ] - } - ] - }, - { - "id": "0x564d8e726f10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26343, - "line": 864, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26356, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e726ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26350, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26356, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55f00", - "kind": "EnumConstantDecl", - "name": "INVERSION_ON", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e728350", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26374, - "line": 865, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26421, - "line": 866, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7282a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26378, - "line": 865, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26383, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e728288", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e728268", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e726f40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26378, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26378, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e728250", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26383, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 26383, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e726f60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26383, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 26383, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"inversion_off\"" - } - ] - } - ] - }, - { - "id": "0x564d8e728340", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26408, - "line": 866, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26421, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e728310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26415, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26421, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55f58", - "kind": "EnumConstantDecl", - "name": "INVERSION_OFF", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e728980", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 26440, - "line": 867, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e728968", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 26440, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e728940", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 26446, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e728920", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26446, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e728918", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7288e8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 26446, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7288d0", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7288b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e728898", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e728890", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e728858", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e728840", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26491, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 26491, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e728820", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26491, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 26491, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e728808", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26459, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e728380", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26459, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char[30]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown external signal flag \"" - } - ] - }, - { - "id": "0x564d8e7283b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26493, - "col": 58, - "tokLen": 1 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e728b60", - "kind": "FunctionDecl", - "loc": { - "offset": 26530, - "file": "ToString.cpp", - "line": 870, - "col": 31, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 26500, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 26953, - "line": 882, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a84c0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11readoutModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::readoutMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "inner": [ - { - "id": "0x564d8dd595b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "decl": { - "id": "0x564d8dd59508", - "kind": "EnumDecl", - "name": "readoutMode" - } - } - ] - }, - { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "loc": { - "offset": 26558, - "line": 870, - "col": 59, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 26539, - "col": 40, - "tokLen": 5 - }, - "end": { - "offset": 26558, - "col": 59, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e72f890", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 26561, - "col": 62, - "tokLen": 1 - }, - "end": { - "offset": 26953, - "line": 882, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e72a150", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26567, - "line": 871, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26607, - "line": 872, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e72a0a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26571, - "line": 871, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26576, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72a088", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26573, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26573, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72a068", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26573, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26573, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e728d48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26571, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26571, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72a050", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26576, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 26576, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e728d68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26576, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 26576, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"analog\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72a140", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26594, - "line": 872, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26607, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e72a110", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26601, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26607, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd595d0", - "kind": "EnumConstantDecl", - "name": "ANALOG_ONLY", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72b580", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26624, - "line": 873, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26665, - "line": 874, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e72b4d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26628, - "line": 873, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26633, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72b4b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26630, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26630, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72b498", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26630, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26630, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72a170", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26628, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26628, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72b480", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26633, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 26633, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72a190", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26633, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 26633, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"digital\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72b570", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26652, - "line": 874, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26665, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e72b540", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26659, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26665, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59628", - "kind": "EnumConstantDecl", - "name": "DIGITAL_ONLY", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72c9b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26683, - "line": 875, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26731, - "line": 876, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e72c900", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26687, - "line": 875, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26692, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72c8e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26689, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26689, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72c8c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26689, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26689, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72b5a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26687, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26687, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72c8b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26692, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 26692, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72b5c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26692, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 26692, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"analog_digital\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72c9a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26718, - "line": 876, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26731, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e72c970", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26725, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26731, - "col": 22, - "tokLen": 18 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59680", - "kind": "EnumConstantDecl", - "name": "ANALOG_AND_DIGITAL", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72dde0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26755, - "line": 877, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26800, - "line": 878, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e72dd30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26759, - "line": 877, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26764, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72dd18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26761, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26761, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72dcf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26761, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26761, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72c9d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26759, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26759, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72dce0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26764, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 26764, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72c9f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26764, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 26764, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"transceiver\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72ddd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26787, - "line": 878, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26800, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e72dda0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26794, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26800, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd596d8", - "kind": "EnumConstantDecl", - "name": "TRANSCEIVER_ONLY", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72f220", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26822, - "line": 879, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26875, - "line": 880, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e72f170", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26826, - "line": 879, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26831, - "col": 14, - "tokLen": 21 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72f158", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26828, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26828, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72f138", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26828, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26828, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72de00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26826, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26826, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72f120", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26831, - "col": 14, - "tokLen": 21 - }, - "end": { - "offset": 26831, - "col": 14, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72de20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26831, - "col": 14, - "tokLen": 21 - }, - "end": { - "offset": 26831, - "col": 14, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char[20]" - }, - "valueCategory": "lvalue", - "value": "\"digital_transceiver\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72f210", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26862, - "line": 880, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26875, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e72f1e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26869, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26875, - "col": 22, - "tokLen": 23 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59730", - "kind": "EnumConstantDecl", - "name": "DIGITAL_AND_TRANSCEIVER", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72f878", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 26904, - "line": 881, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e72f860", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 26904, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e72f838", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 26910, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e72f818", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26910, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e72f810", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e72f7e0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 26910, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e72f7c8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e72f7b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e72f790", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e72f788", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e72f750", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72f738", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26947, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 26947, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72f718", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26947, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 26947, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e72f700", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26923, - "col": 24, - "tokLen": 23 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72f250", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26923, - "col": 24, - "tokLen": 23 - } - }, - "type": { - "qualType": "const char[22]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown readout mode \"" - } - ] - }, - { - "id": "0x564d8e72f280", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26949, - "col": 50, - "tokLen": 1 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e72fa60", - "kind": "FunctionDecl", - "loc": { - "offset": 26983, - "file": "ToString.cpp", - "line": 884, - "col": 28, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 26956, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 32146, - "line": 1062, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a8a50", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8dacIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::dacIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "inner": [ - { - "id": "0x564d8dd56380", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "decl": { - "id": "0x564d8dd562d8", - "kind": "EnumDecl", - "name": "dacIndex" - } - } - ] - }, - { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "loc": { - "offset": 27011, - "line": 884, - "col": 56, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 26992, - "col": 37, - "tokLen": 5 - }, - "end": { - "offset": 27011, - "col": 56, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7b55f0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 27014, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 32146, - "line": 1062, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e732400", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27020, - "line": 885, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27071, - "line": 886, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e732368", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27024, - "line": 885, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e730fa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27024, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27029, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e730f88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e730f68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72fc48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27024, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27024, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e730f50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27029, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27029, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72fc68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27029, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27029, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e732330", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27040, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e732318", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27042, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27042, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7322f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27042, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27042, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e730fd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27040, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27040, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7322e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27045, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e730ff8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27045, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"0\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7323f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27058, - "line": 886, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27071, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7323c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27065, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27071, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd563a0", - "kind": "EnumConstantDecl", - "name": "DAC_0", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e734be0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27082, - "line": 887, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27133, - "line": 888, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e734b48", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27086, - "line": 887, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e733780", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27086, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27091, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e733768", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27088, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27088, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e733748", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27088, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27088, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e732420", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27086, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27086, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e733730", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27091, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27091, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e732440", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27091, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27091, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e734b10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27102, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e734af8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27104, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27104, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e734ad8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27104, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27104, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7337b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27102, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27102, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e734ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27107, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7337d8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27107, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"1\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e734bd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27120, - "line": 888, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27133, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e734ba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27127, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27133, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd563f8", - "kind": "EnumConstantDecl", - "name": "DAC_1", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7373c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27144, - "line": 889, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27195, - "line": 890, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e737328", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27148, - "line": 889, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e735f60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27148, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27153, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e735f48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27150, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27150, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e735f28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27150, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27150, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e734c00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27148, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27148, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e735f10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27153, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27153, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e734c20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27153, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27153, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7372f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27164, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7372d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27166, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27166, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7372b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27166, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27166, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e735f98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27164, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27164, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7372a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27169, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e735fb8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27169, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"2\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7373b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27182, - "line": 890, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27195, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e737380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27189, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27195, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56450", - "kind": "EnumConstantDecl", - "name": "DAC_2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e739ba0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27206, - "line": 891, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27257, - "line": 892, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e739b08", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27210, - "line": 891, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e738740", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27210, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27215, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e738728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e738708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7373e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27210, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27210, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7386f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27215, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27215, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e737400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27215, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27215, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 3\"" - } - ] - } - ] - }, - { - "id": "0x564d8e739ad0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27226, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e739ab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27228, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27228, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e739a98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27228, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27228, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e738778", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27226, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27226, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e739a80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27231, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e738798", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27231, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"3\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e739b90", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27244, - "line": 892, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27257, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e739b60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27251, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27257, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd564a8", - "kind": "EnumConstantDecl", - "name": "DAC_3", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e73c390", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27268, - "line": 893, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27319, - "line": 894, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73c2f8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27272, - "line": 893, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e73af30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27272, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27277, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73af18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27274, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27274, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73aef8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27274, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27274, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e739bc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27272, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27272, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73aee0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27277, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27277, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e739be0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27277, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27277, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 4\"" - } - ] - } - ] - }, - { - "id": "0x564d8e73c2c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27288, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73c2a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27290, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27290, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73c288", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27290, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27290, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73af68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27288, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27288, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73c270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27293, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73af88", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27293, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"4\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e73c380", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27306, - "line": 894, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27319, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73c350", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27313, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27319, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56500", - "kind": "EnumConstantDecl", - "name": "DAC_4", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e73eb70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27330, - "line": 895, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27381, - "line": 896, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73ead8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27334, - "line": 895, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e73d710", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27334, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27339, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73d6f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27336, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27336, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73d6d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27336, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27336, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73c3b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27334, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27334, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73d6c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27339, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27339, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73c3d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27339, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27339, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 5\"" - } - ] - } - ] - }, - { - "id": "0x564d8e73eaa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27350, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73ea88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27352, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27352, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73ea68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27352, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27352, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73d748", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27350, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27350, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73ea50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27355, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73d768", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27355, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"5\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e73eb60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27368, - "line": 896, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27381, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73eb30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27375, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27381, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56558", - "kind": "EnumConstantDecl", - "name": "DAC_5", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e741350", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27392, - "line": 897, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27443, - "line": 898, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7412b8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27396, - "line": 897, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e73fef0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27396, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27401, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73fed8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27398, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27398, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73feb8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27398, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27398, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73eb90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27396, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27396, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73fea0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27401, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27401, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73ebb0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27401, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27401, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 6\"" - } - ] - } - ] - }, - { - "id": "0x564d8e741280", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27412, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e741268", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27414, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27414, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e741248", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27414, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27414, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73ff28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27412, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27412, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e741230", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27417, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73ff48", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27417, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"6\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e741340", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27430, - "line": 898, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27443, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e741310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27437, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27443, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd565b0", - "kind": "EnumConstantDecl", - "name": "DAC_6", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e743b30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27454, - "line": 899, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27505, - "line": 900, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e743a98", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27458, - "line": 899, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7426d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27458, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27463, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7426b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27460, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27460, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e742698", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27460, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27460, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e741370", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27458, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27458, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e742680", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27463, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27463, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e741390", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27463, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27463, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 7\"" - } - ] - } - ] - }, - { - "id": "0x564d8e743a60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27474, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e743a48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27476, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27476, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e743a28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27476, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27476, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e742708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27474, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27474, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e743a10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27479, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e742728", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27479, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"7\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e743b20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27492, - "line": 900, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27505, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e743af0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27499, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27505, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56608", - "kind": "EnumConstantDecl", - "name": "DAC_7", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e746310", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27516, - "line": 901, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27567, - "line": 902, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e746278", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27520, - "line": 901, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e744eb0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27520, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27525, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e744e98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27522, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27522, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e744e78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27522, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27522, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e743b50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27520, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27520, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e744e60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27525, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27525, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e743b70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27525, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27525, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 8\"" - } - ] - } - ] - }, - { - "id": "0x564d8e746240", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27536, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e746228", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27538, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27538, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e746208", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27538, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27538, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e744ee8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27536, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27536, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7461f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27541, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e744f08", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27541, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"8\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e746300", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27554, - "line": 902, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27567, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7462d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27561, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27567, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56660", - "kind": "EnumConstantDecl", - "name": "DAC_8", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e748af0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27578, - "line": 903, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27629, - "line": 904, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e748a58", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27582, - "line": 903, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e747690", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27587, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e747678", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e747658", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e746330", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27582, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e747640", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27587, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27587, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e746350", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27587, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27587, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 9\"" - } - ] - } - ] - }, - { - "id": "0x564d8e748a20", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27598, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e748a08", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27600, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27600, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7489e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27600, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27600, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7476c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27598, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27598, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7489d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27603, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7476e8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27603, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"9\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e748ae0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27616, - "line": 904, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27629, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e748ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27623, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27629, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd566b8", - "kind": "EnumConstantDecl", - "name": "DAC_9", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e74b2d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27640, - "line": 905, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27693, - "line": 906, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74b238", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27644, - "line": 905, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e749e70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27644, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27649, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e749e58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27646, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27646, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e749e38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27646, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27646, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e748b10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27644, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27644, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e749e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27649, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27649, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e748b30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27649, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27649, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 10\"" - } - ] - } - ] - }, - { - "id": "0x564d8e74b200", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27661, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74b1e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27663, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27663, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74b1c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27663, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27663, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e749ea8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27661, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27661, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74b1b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27666, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e749ec8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27666, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"10\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e74b2c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27680, - "line": 906, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27693, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74b290", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27687, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27693, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56710", - "kind": "EnumConstantDecl", - "name": "DAC_10", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e74dab0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27705, - "line": 907, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27758, - "line": 908, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74da18", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27709, - "line": 907, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e74c650", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27709, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27714, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74c638", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27711, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27711, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74c618", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27711, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27711, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74b2f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27709, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27709, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74c600", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27714, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27714, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74b310", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27714, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27714, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 11\"" - } - ] - } - ] - }, - { - "id": "0x564d8e74d9e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27726, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74d9c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27728, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27728, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74d9a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27728, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27728, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74c688", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27726, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27726, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74d990", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27731, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74c6a8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27731, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"11\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e74daa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27745, - "line": 908, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27758, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74da70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27752, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27758, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56768", - "kind": "EnumConstantDecl", - "name": "DAC_11", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e750290", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27770, - "line": 909, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27823, - "line": 910, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7501f8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27774, - "line": 909, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e74ee30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27774, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27779, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74ee18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74edf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74dad0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27774, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27774, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74ede0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27779, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27779, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74daf0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27779, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27779, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 12\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7501c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27791, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7501a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27793, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27793, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e750188", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27793, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27793, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74ee68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27791, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27791, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e750170", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27796, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74ee88", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27796, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"12\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e750280", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27810, - "line": 910, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27823, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e750250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27817, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27823, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd567c0", - "kind": "EnumConstantDecl", - "name": "DAC_12", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e752a70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27835, - "line": 911, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27888, - "line": 912, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7529d8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27839, - "line": 911, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e751610", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27839, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27844, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7515f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27841, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27841, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7515d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27841, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27841, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7502b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27839, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27839, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7515c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27844, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27844, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7502d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27844, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27844, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 13\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7529a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27856, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e752988", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27858, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27858, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e752968", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27858, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27858, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e751648", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27856, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27856, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e752950", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27861, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e751668", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27861, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"13\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e752a60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27875, - "line": 912, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27888, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e752a30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27882, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27888, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56818", - "kind": "EnumConstantDecl", - "name": "DAC_13", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e755250", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27900, - "line": 913, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27953, - "line": 914, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7551b8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27904, - "line": 913, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e753df0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27904, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27909, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e753dd8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27906, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27906, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e753db8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27906, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27906, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e752a90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27904, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27904, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e753da0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27909, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27909, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e752ab0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27909, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27909, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 14\"" - } - ] - } - ] - }, - { - "id": "0x564d8e755180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27921, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e755168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27923, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27923, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e755148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27923, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27923, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e753e28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27921, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27921, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e755130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27926, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e753e48", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27926, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"14\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e755240", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27940, - "line": 914, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27953, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e755210", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27947, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27953, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56870", - "kind": "EnumConstantDecl", - "name": "DAC_14", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e757a30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27965, - "line": 915, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28018, - "line": 916, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e757998", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27969, - "line": 915, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7565d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27969, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27974, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7565b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27971, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27971, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e756598", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27971, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27971, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e755270", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27969, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27969, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e756580", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27974, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27974, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e755290", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27974, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27974, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 15\"" - } - ] - } - ] - }, - { - "id": "0x564d8e757960", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27986, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e757948", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27988, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27988, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e757928", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27988, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27988, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e756608", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27986, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27986, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e757910", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27991, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e756628", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27991, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"15\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e757a20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28005, - "line": 916, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28018, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7579f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28012, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28018, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd568c8", - "kind": "EnumConstantDecl", - "name": "DAC_15", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75a210", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28030, - "line": 917, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28083, - "line": 918, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75a178", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 28034, - "line": 917, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e758db0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28034, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28039, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e758d98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28036, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28036, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e758d78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28036, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28036, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e757a50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28034, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28034, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e758d60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28039, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28039, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e757a70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28039, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28039, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 16\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75a140", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28051, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75a128", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28053, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28053, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75a108", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28053, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28053, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e758de8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28051, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28051, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75a0f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28056, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e758e08", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28056, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"16\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e75a200", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28070, - "line": 918, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28083, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75a1d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28077, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28083, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56920", - "kind": "EnumConstantDecl", - "name": "DAC_16", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75ca40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28095, - "line": 919, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28148, - "line": 920, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75c9a8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 28099, - "line": 919, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e75b5e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28099, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28104, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75b5c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28101, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28101, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75b5a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28101, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28101, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75a230", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28099, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28099, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75b590", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28104, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28104, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75a250", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28104, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28104, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 17\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75c970", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28116, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75c958", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28118, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28118, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75c938", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28118, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28118, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75b618", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28116, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28116, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75c920", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28121, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75b638", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28121, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"17\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e75ca30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28135, - "line": 920, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28148, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75ca00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28142, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28148, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56978", - "kind": "EnumConstantDecl", - "name": "DAC_17", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75de70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28160, - "line": 921, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28198, - "line": 922, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e75ddc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28164, - "line": 921, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28169, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75dda8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28166, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28166, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75dd88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28166, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28166, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75ca60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28164, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28164, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75dd70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28169, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28169, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75ca80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28169, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28169, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vsvp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75de60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28185, - "line": 922, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28198, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e75de30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28192, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28198, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd569d0", - "kind": "EnumConstantDecl", - "name": "VSVP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75f2a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28208, - "line": 923, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28247, - "line": 924, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e75f1f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28212, - "line": 923, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28217, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75f1d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28214, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28214, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75f1b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28214, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28214, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75de90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28212, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28212, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75f1a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28217, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 28217, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75deb0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28217, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 28217, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vtrim\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75f290", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28234, - "line": 924, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28247, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e75f260", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28241, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28247, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56a28", - "kind": "EnumConstantDecl", - "name": "VTRIM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7606d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28258, - "line": 925, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28300, - "line": 926, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e760620", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28262, - "line": 925, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28267, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e760608", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28264, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28264, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7605e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28264, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28264, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75f2c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28262, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28262, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7605d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28267, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28267, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75f2e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28267, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28267, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vrpreamp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7606c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28287, - "line": 926, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28300, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e760690", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28294, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28300, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56a80", - "kind": "EnumConstantDecl", - "name": "VRPREAMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e761b00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28314, - "line": 927, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28356, - "line": 928, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e761a50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28318, - "line": 927, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28323, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e761a38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28320, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28320, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e761a18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28320, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28320, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7606f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28318, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28318, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e761a00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28323, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28323, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e760710", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28323, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28323, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vrshaper\"" - } - ] - } - ] - }, - { - "id": "0x564d8e761af0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28343, - "line": 928, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28356, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e761ac0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28350, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28356, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ad8", - "kind": "EnumConstantDecl", - "name": "VRSHAPER", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e762f30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28370, - "line": 929, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28408, - "line": 930, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e762e80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28374, - "line": 929, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28379, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e762e68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28376, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28376, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e762e48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28376, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28376, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e761b20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28374, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28374, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e762e30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28379, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28379, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e761b40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28379, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28379, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vsvn\"" - } - ] - } - ] - }, - { - "id": "0x564d8e762f20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28395, - "line": 930, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28408, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e762ef0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28402, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28408, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56b30", - "kind": "EnumConstantDecl", - "name": "VSVN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e764360", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28418, - "line": 931, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28458, - "line": 932, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7642b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28422, - "line": 931, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28427, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e764298", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28424, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28424, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e764278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28424, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28424, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e762f50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28422, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28422, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e764260", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28427, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28427, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e762f70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28427, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28427, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vtgstv\"" - } - ] - } - ] - }, - { - "id": "0x564d8e764350", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28445, - "line": 932, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28458, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e764320", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28452, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28458, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56b88", - "kind": "EnumConstantDecl", - "name": "VTGSTV", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e765790", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28470, - "line": 933, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28511, - "line": 934, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7656e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28474, - "line": 933, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28479, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7656c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28476, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28476, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7656a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28476, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28476, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e764380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28474, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28474, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e765690", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28479, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28479, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7643a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28479, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28479, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_ll\"" - } - ] - } - ] - }, - { - "id": "0x564d8e765780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28498, - "line": 934, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28511, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e765750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28505, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28511, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56be0", - "kind": "EnumConstantDecl", - "name": "VCMP_LL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e766bc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28524, - "line": 935, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28565, - "line": 936, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e766b10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28528, - "line": 935, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28533, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e766af8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28530, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28530, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e766ad8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28530, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28530, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7657b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28528, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28528, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e766ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28533, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28533, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7657d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28533, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28533, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_lr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e766bb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28552, - "line": 936, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28565, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e766b80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28559, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28565, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56c38", - "kind": "EnumConstantDecl", - "name": "VCMP_LR", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e767ff0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28578, - "line": 937, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28616, - "line": 938, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e767f40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28582, - "line": 937, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e767f28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e767f08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e766be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28582, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e767ef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e766c00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vcal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e767fe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28603, - "line": 938, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28616, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e767fb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28610, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28616, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56c90", - "kind": "EnumConstantDecl", - "name": "VCAL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e769420", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28626, - "line": 939, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28667, - "line": 940, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e769370", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28630, - "line": 939, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28635, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e769358", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e769338", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e768010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28630, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28630, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e769320", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28635, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28635, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e768030", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28635, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28635, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_rl\"" - } - ] - } - ] - }, - { - "id": "0x564d8e769410", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28654, - "line": 940, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28667, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7693e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28661, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28667, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ce8", - "kind": "EnumConstantDecl", - "name": "VCMP_RL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76a850", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28680, - "line": 941, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28720, - "line": 942, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76a7a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28684, - "line": 941, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28689, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76a788", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28686, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28686, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76a768", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28686, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28686, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e769440", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28684, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28684, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76a750", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28689, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28689, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e769460", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28689, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28689, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"rxb_rb\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76a840", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28707, - "line": 942, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28720, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76a810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28714, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28720, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56d40", - "kind": "EnumConstantDecl", - "name": "RXB_RB", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76bc80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28732, - "line": 943, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28772, - "line": 944, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76bbd0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28736, - "line": 943, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28741, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76bbb8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28738, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28738, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76bb98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28738, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28738, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76a870", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28736, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28736, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76bb80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28741, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28741, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76a890", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28741, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28741, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"rxb_lb\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76bc70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28759, - "line": 944, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28772, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76bc40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28766, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28772, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56d98", - "kind": "EnumConstantDecl", - "name": "RXB_LB", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76d0b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28784, - "line": 945, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28825, - "line": 946, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e76d000", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28788, - "line": 945, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28793, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76cfe8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28790, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28790, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76cfc8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28790, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28790, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76bca0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28788, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28788, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76cfb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28793, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28793, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76bcc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28793, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28793, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_rr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76d0a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28812, - "line": 946, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28825, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e76d070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28819, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28825, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56df0", - "kind": "EnumConstantDecl", - "name": "VCMP_RR", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76e4e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28838, - "line": 947, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28875, - "line": 948, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76e430", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28842, - "line": 947, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28847, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76e418", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28844, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28844, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76e3f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28844, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28844, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76d0d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28842, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28842, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76e3e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28847, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28847, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76d0f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28847, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28847, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"vcp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76e4d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28862, - "line": 948, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28875, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76e4a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28869, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28875, - "col": 22, - "tokLen": 3 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56e48", - "kind": "EnumConstantDecl", - "name": "VCP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76f910", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28884, - "line": 949, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28921, - "line": 950, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76f860", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28888, - "line": 949, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28893, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76f848", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28890, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28890, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76f828", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28890, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28890, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76e500", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28888, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28888, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76f810", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28893, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28893, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76e520", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28893, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28893, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"vcn\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76f900", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28908, - "line": 950, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28921, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76f8d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28915, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28921, - "col": 22, - "tokLen": 3 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ea0", - "kind": "EnumConstantDecl", - "name": "VCN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e770d40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28930, - "line": 951, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28972, - "line": 952, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e770c90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28934, - "line": 951, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28939, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e770c78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28936, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28936, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e770c58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28936, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28936, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76f930", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28934, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28934, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e770c40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28939, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28939, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76f950", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28939, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28939, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vishaper\"" - } - ] - } - ] - }, - { - "id": "0x564d8e770d30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28959, - "line": 952, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28972, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e770d00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28966, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28972, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ef8", - "kind": "EnumConstantDecl", - "name": "VISHAPER", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e772170", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28986, - "line": 953, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29030, - "line": 954, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7720c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28990, - "line": 953, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28995, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7720a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e772088", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e770d60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28990, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28990, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e772070", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28995, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 28995, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e770d80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28995, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 28995, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vthreshold\"" - } - ] - } - ] - }, - { - "id": "0x564d8e772160", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29017, - "line": 954, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29030, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e772130", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29024, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29030, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56f50", - "kind": "EnumConstantDecl", - "name": "VTHRESHOLD", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7735a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29046, - "line": 955, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29087, - "line": 956, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7734f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29050, - "line": 955, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29055, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7734d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29052, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29052, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7734b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29052, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29052, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e772190", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29050, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29050, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7734a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29055, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29055, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7721b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29055, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29055, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vref_ds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e773590", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29074, - "line": 956, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29087, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e773560", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29081, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29087, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57000", - "kind": "EnumConstantDecl", - "name": "VREF_DS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7749d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29100, - "line": 957, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29141, - "line": 958, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e774920", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29104, - "line": 957, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29109, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e774908", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29106, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29106, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7748e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29106, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29106, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7735c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29104, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29104, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7748d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29109, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29109, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7735e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29109, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29109, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vout_cm\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7749c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29128, - "line": 958, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29141, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e774990", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29135, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29141, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57058", - "kind": "EnumConstantDecl", - "name": "VOUT_CM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e775e00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29154, - "line": 959, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29194, - "line": 960, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e775d50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29158, - "line": 959, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29163, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e775d38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29160, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29160, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e775d18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29160, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29160, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7749f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29158, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29158, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e775d00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29163, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 29163, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e774a10", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29163, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 29163, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vin_cm\"" - } - ] - } - ] - }, - { - "id": "0x564d8e775df0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29181, - "line": 960, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29194, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e775dc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29188, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29194, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd570b0", - "kind": "EnumConstantDecl", - "name": "VIN_CM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e777230", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29206, - "line": 961, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29249, - "line": 962, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e777180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29210, - "line": 961, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29215, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e777168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e777148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e775e20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29210, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29210, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e777130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29215, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29215, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e775e40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29215, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29215, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vref_comp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e777220", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29236, - "line": 962, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29249, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7771f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29243, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29249, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57108", - "kind": "EnumConstantDecl", - "name": "VREF_COMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e778660", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29264, - "line": 963, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29305, - "line": 964, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7785b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29268, - "line": 963, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29273, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e778598", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29270, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29270, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e778578", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29270, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29270, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e777250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29268, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29268, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e778560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29273, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29273, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e777270", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29273, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29273, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vb_comp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e778650", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29292, - "line": 964, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29305, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e778620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29299, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29305, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57160", - "kind": "EnumConstantDecl", - "name": "VB_COMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e779a90", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29318, - "line": 965, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29360, - "line": 966, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7799e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29322, - "line": 965, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29327, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7799c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29324, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29324, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7799a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29324, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29324, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e778680", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29322, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29322, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e779990", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29327, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29327, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7786a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29327, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29327, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vdd_prot\"" - } - ] - } - ] - }, - { - "id": "0x564d8e779a80", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29347, - "line": 966, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29360, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e779a50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29354, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29360, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd571b8", - "kind": "EnumConstantDecl", - "name": "VDD_PROT", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77aef0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29374, - "line": 967, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29415, - "line": 968, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e77ae40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29378, - "line": 967, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29383, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77ae28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77ae08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e779ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29378, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29378, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77adf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29383, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29383, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e779ad0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29383, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29383, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vin_com\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77aee0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29402, - "line": 968, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29415, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e77aeb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29409, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29415, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57210", - "kind": "EnumConstantDecl", - "name": "VIN_COM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77c320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29428, - "line": 969, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29472, - "line": 970, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77c270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29432, - "line": 969, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29437, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77c258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29434, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29434, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77c238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29434, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29434, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77af10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29432, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29432, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77c220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29437, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29437, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77af30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29437, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29437, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vref_prech\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77c310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29459, - "line": 970, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29472, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77c2e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29466, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29472, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57268", - "kind": "EnumConstantDecl", - "name": "VREF_PRECH", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77d750", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29488, - "line": 971, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29531, - "line": 972, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e77d6a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29492, - "line": 971, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29497, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77d688", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29494, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29494, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77d668", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29494, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29494, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77c340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29492, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29492, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77d650", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29497, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29497, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77c360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29497, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29497, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vb_pixbuf\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77d740", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29518, - "line": 972, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29531, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e77d710", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29525, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29531, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd572c0", - "kind": "EnumConstantDecl", - "name": "VB_PIXBUF", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77eb80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29546, - "line": 973, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29585, - "line": 974, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e77ead0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29550, - "line": 973, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29555, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77eab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29552, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29552, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77ea98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29552, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29552, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77d770", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29550, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29550, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77ea80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29555, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 29555, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77d790", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29555, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 29555, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vb_ds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77eb70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29572, - "line": 974, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29585, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e77eb40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29579, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29585, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57318", - "kind": "EnumConstantDecl", - "name": "VB_DS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77ffb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29596, - "line": 975, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29640, - "line": 976, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77ff00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29600, - "line": 975, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29605, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77fee8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29602, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29602, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77fec8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29602, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29602, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77eba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29600, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29600, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77feb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29605, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29605, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77ebc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29605, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29605, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vref_h_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77ffa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29627, - "line": 976, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29640, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77ff70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29634, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29640, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57370", - "kind": "EnumConstantDecl", - "name": "VREF_H_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7813e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29656, - "line": 977, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29700, - "line": 978, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e781330", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29660, - "line": 977, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29665, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e781318", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29662, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29662, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7812f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29662, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29662, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77ffd0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29660, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29660, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7812e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29665, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29665, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77fff0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29665, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29665, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vb_comp_fe\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7813d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29687, - "line": 978, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29700, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7813a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29694, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29700, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd573c8", - "kind": "EnumConstantDecl", - "name": "VB_COMP_FE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e782810", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29716, - "line": 979, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29761, - "line": 980, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e782760", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29720, - "line": 979, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29725, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e782748", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29722, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29722, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e782728", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29722, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29722, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e781400", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29720, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29720, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e782710", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29725, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29725, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e781420", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29725, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29725, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"vb_comp_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e782800", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29748, - "line": 980, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29761, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e7827d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29755, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29761, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57420", - "kind": "EnumConstantDecl", - "name": "VB_COMP_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e783c40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29778, - "line": 981, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29820, - "line": 982, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e783b90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29782, - "line": 981, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29787, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e783b78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29784, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29784, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e783b58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29784, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29784, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e782830", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29782, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29782, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e783b40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29787, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29787, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e782850", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29787, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29787, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vcom_cds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e783c30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29807, - "line": 982, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29820, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e783c00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29814, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29820, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57478", - "kind": "EnumConstantDecl", - "name": "VCOM_CDS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e785070", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29834, - "line": 983, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29879, - "line": 984, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e784fc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29838, - "line": 983, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29843, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e784fa8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e784f88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e783c60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29838, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29838, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e784f70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29843, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29843, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e783c80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29843, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29843, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"vref_rstore\"" - } - ] - } - ] - }, - { - "id": "0x564d8e785060", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29866, - "line": 984, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29879, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e785030", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29873, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29879, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd574d0", - "kind": "EnumConstantDecl", - "name": "VREF_RSTORE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7864a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29896, - "line": 985, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29940, - "line": 986, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7863f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29900, - "line": 985, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29905, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7863d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29902, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29902, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7863b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29902, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29902, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e785090", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29900, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29900, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7863a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29905, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29905, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7850b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29905, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29905, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vb_opa_1st\"" - } - ] - } - ] - }, - { - "id": "0x564d8e786490", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29927, - "line": 986, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29940, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e786460", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29934, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29940, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57528", - "kind": "EnumConstantDecl", - "name": "VB_OPA_1ST", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7878d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29956, - "line": 987, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30002, - "line": 988, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e787820", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29960, - "line": 987, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29965, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e787808", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29962, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29962, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7877e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29962, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29962, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7864c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29960, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29960, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7877d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29965, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 29965, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7864e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29965, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 29965, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"vref_comp_fe\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7878c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29989, - "line": 988, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30002, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e787890", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29996, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30002, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57580", - "kind": "EnumConstantDecl", - "name": "VREF_COMP_FE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e788d00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30020, - "line": 989, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30063, - "line": 990, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e788c50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30024, - "line": 989, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30029, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e788c38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e788c18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7878f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30024, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30024, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e788c00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30029, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30029, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e787910", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30029, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30029, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vcom_adc1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e788cf0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30050, - "line": 990, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30063, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e788cc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30057, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30063, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd575d8", - "kind": "EnumConstantDecl", - "name": "VCOM_ADC1", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78a130", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30078, - "line": 991, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30122, - "line": 992, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e78a080", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30082, - "line": 991, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30087, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78a068", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30084, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30084, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78a048", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30084, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30084, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e788d20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30082, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30082, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78a030", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30087, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30087, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e788d40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30087, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30087, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vref_l_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78a120", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30109, - "line": 992, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30122, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e78a0f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30116, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30122, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57630", - "kind": "EnumConstantDecl", - "name": "VREF_L_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78b560", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30138, - "line": 993, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30180, - "line": 994, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e78b4b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30142, - "line": 993, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30147, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78b498", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30144, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30144, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78b478", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30144, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30144, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78a150", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30142, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30142, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78b460", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30147, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 30147, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78a170", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30147, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 30147, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vref_cds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78b550", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30167, - "line": 994, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30180, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e78b520", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30174, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30180, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57688", - "kind": "EnumConstantDecl", - "name": "VREF_CDS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78c990", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30194, - "line": 995, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30233, - "line": 996, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e78c8e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30198, - "line": 995, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30203, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78c8c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30200, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30200, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78c8a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30200, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30200, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78b580", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30198, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30198, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78c890", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30203, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30203, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78b5a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30203, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30203, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vb_cs\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78c980", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30220, - "line": 996, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30233, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e78c950", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30227, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30233, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd576e0", - "kind": "EnumConstantDecl", - "name": "VB_CS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78ddc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30244, - "line": 997, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30287, - "line": 998, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78dd10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30248, - "line": 997, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30253, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78dcf8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30250, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30250, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78dcd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30250, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30250, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78c9b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30248, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30248, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78dcc0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30253, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30253, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78c9d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30253, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30253, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vb_opa_fd\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78ddb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30274, - "line": 998, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30287, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78dd80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30281, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30287, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57738", - "kind": "EnumConstantDecl", - "name": "VB_OPA_FD", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78f1f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30302, - "line": 999, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30345, - "line": 1000, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78f140", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30306, - "line": 999, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30311, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78f128", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30308, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30308, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78f108", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30308, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30308, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78dde0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30306, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30306, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78f0f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30311, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30311, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78de00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30311, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30311, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vcom_adc2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78f1e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30332, - "line": 1000, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30345, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78f1b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30339, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30345, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57790", - "kind": "EnumConstantDecl", - "name": "VCOM_ADC2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e790620", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30360, - "line": 1001, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30400, - "line": 1002, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e790570", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30364, - "line": 1001, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30369, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e790558", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30366, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30366, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e790538", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30366, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30366, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78f210", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30364, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30364, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e790520", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30369, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30369, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78f230", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30369, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30369, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vcassh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e790610", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30387, - "line": 1002, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30400, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7905e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30394, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30400, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd577e8", - "kind": "EnumConstantDecl", - "name": "VCASSH", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e791a50", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30412, - "line": 1003, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30450, - "line": 1004, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7919a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30416, - "line": 1003, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30421, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e791988", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30418, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30418, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e791968", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30418, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30418, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e790640", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30416, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30416, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e791950", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30421, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30421, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e790660", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30421, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30421, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vth2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e791a40", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30437, - "line": 1004, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30450, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e791a10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30444, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30450, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57840", - "kind": "EnumConstantDecl", - "name": "VTH2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e792e80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30460, - "line": 1005, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30504, - "line": 1006, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e792dd0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30464, - "line": 1005, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30469, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e792db8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30466, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30466, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e792d98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30466, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30466, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e791a70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30464, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30464, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e792d80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30469, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30469, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e791a90", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30469, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30469, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vrshaper_n\"" - } - ] - } - ] - }, - { - "id": "0x564d8e792e70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30491, - "line": 1006, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30504, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e792e40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30498, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30504, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57898", - "kind": "EnumConstantDecl", - "name": "VRSHAPER_N", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7942b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30520, - "line": 1007, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30563, - "line": 1008, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e794200", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30524, - "line": 1007, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30529, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7941e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30526, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30526, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7941c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30526, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30526, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e792ea0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30524, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30524, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7941b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30529, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30529, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e792ec0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30529, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30529, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vipre_out\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7942a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30550, - "line": 1008, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30563, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e794270", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30557, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30563, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd578f0", - "kind": "EnumConstantDecl", - "name": "VIPRE_OUT", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7956e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30578, - "line": 1009, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30616, - "line": 1010, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e795630", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30582, - "line": 1009, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e795618", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7955f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7942d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30582, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7955e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7942f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vth3\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7956d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30603, - "line": 1010, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30616, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7956a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30610, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30616, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57948", - "kind": "EnumConstantDecl", - "name": "VTH3", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e796b10", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30626, - "line": 1011, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30664, - "line": 1012, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e796a60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30630, - "line": 1011, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30635, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e796a48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e796a28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e795700", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30630, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30630, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e796a10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30635, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30635, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e795720", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30635, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30635, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vth1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e796b00", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30651, - "line": 1012, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30664, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e796ad0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30658, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30664, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd579a0", - "kind": "EnumConstantDecl", - "name": "VTH1", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e797f40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30674, - "line": 1013, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30713, - "line": 1014, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e797e90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30678, - "line": 1013, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30683, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e797e78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30680, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30680, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e797e58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30680, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30680, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e796b30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30678, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30678, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e797e40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30683, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30683, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e796b50", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30683, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30683, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vicin\"" - } - ] - } - ] - }, - { - "id": "0x564d8e797f30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30700, - "line": 1014, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30713, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e797f00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30707, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30713, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd579f8", - "kind": "EnumConstantDecl", - "name": "VICIN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e799370", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30724, - "line": 1015, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30762, - "line": 1016, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7992c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30728, - "line": 1015, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30733, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7992a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30730, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30730, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e799288", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30730, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30730, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e797f60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30728, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30728, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e799270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30733, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30733, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e797f80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30733, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30733, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vcas\"" - } - ] - } - ] - }, - { - "id": "0x564d8e799360", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30749, - "line": 1016, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30762, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e799330", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30756, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30762, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57a50", - "kind": "EnumConstantDecl", - "name": "VCAS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79a7a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30772, - "line": 1017, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30812, - "line": 1018, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79a6f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30776, - "line": 1017, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30781, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79a6d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30778, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30778, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79a6b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30778, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30778, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e799390", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30776, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30776, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79a6a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30781, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30781, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7993b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30781, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30781, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vcal_n\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79a790", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30799, - "line": 1018, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30812, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79a760", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30806, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30812, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57aa8", - "kind": "EnumConstantDecl", - "name": "VCAL_N", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79bbf0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30824, - "line": 1019, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30863, - "line": 1020, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79bb40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30828, - "line": 1019, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30833, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79bb28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30830, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30830, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79bb08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30830, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30830, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79a7e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30828, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30828, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79baf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30833, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30833, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79a800", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30833, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30833, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vipre\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79bbe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30850, - "line": 1020, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30863, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79bbb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30857, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30863, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57b00", - "kind": "EnumConstantDecl", - "name": "VIPRE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79d020", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30874, - "line": 1021, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30914, - "line": 1022, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79cf70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30878, - "line": 1021, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30883, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79cf58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30880, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30880, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79cf38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30880, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30880, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79bc10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30878, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30878, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79cf20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30883, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30883, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79bc30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30883, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30883, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vcal_p\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79d010", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30901, - "line": 1022, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30914, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79cfe0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30908, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30914, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57b58", - "kind": "EnumConstantDecl", - "name": "VCAL_P", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79e450", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30926, - "line": 1023, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30965, - "line": 1024, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79e3a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30930, - "line": 1023, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30935, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79e388", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30932, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30932, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79e368", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30932, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30932, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79d040", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30930, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30930, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79e350", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30935, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30935, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79d060", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30935, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30935, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vdcsh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79e440", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30952, - "line": 1024, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30965, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79e410", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30959, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30965, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57bb0", - "kind": "EnumConstantDecl", - "name": "VDCSH", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79f880", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30976, - "line": 1025, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31020, - "line": 1026, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e79f7d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30980, - "line": 1025, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30985, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79f7b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30982, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30982, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79f798", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30982, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30982, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79e470", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30980, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30980, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79f780", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30985, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30985, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79e490", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30985, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30985, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vbp_colbuf\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79f870", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31007, - "line": 1026, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31020, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e79f840", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31014, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31020, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57c08", - "kind": "EnumConstantDecl", - "name": "VBP_COLBUF", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a0cb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31036, - "line": 1027, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31076, - "line": 1028, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7a0c00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31040, - "line": 1027, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31045, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a0be8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31042, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31042, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a0bc8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31042, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31042, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79f8a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31040, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31040, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a0bb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31045, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 31045, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79f8c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31045, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 31045, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vb_sda\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a0ca0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31063, - "line": 1028, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31076, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7a0c70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31070, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31076, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57c60", - "kind": "EnumConstantDecl", - "name": "VB_SDA", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a20e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31088, - "line": 1029, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31131, - "line": 1030, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a2030", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31092, - "line": 1029, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31097, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a2018", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31094, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31094, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a1ff8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31094, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31094, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a0cd0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31092, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31092, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a1fe0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31097, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31097, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a0cf0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31097, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31097, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vcasc_sfp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a20d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31118, - "line": 1030, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31131, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a20a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31125, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31131, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57cb8", - "kind": "EnumConstantDecl", - "name": "VCASC_SFP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a3510", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31146, - "line": 1031, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31189, - "line": 1032, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a3460", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31150, - "line": 1031, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31155, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a3448", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31152, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31152, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a3428", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31152, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31152, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a2100", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31150, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31150, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a3410", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31155, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31155, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a2120", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31155, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31155, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vipre_cds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a3500", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31176, - "line": 1032, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31189, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a34d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31183, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31189, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57d10", - "kind": "EnumConstantDecl", - "name": "VIPRE_CDS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a4940", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31204, - "line": 1033, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31247, - "line": 1034, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a4890", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31208, - "line": 1033, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31213, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a4878", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31210, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31210, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a4858", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31210, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31210, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a3530", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31208, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31208, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a4840", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31213, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31213, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a3550", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31213, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31213, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"ibias_sfp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a4930", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31234, - "line": 1034, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31247, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a4900", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31241, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31247, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57d68", - "kind": "EnumConstantDecl", - "name": "IBIAS_SFP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a5d70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31262, - "line": 1035, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31304, - "line": 1036, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a5cc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31266, - "line": 1035, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31271, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a5ca8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31268, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31268, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a5c88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31268, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31268, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a4960", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31266, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31266, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a5c70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31271, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31271, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a4980", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31271, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31271, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"trimbits\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a5d60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31291, - "line": 1036, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31304, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a5d30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31298, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31304, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58188", - "kind": "EnumConstantDecl", - "name": "TRIMBIT_SCAN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a71a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31322, - "line": 1037, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31367, - "line": 1038, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a70f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31326, - "line": 1037, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31331, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a70d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31328, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31328, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a70b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31328, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31328, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a5d90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31326, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31326, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a70a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31331, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31331, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a5db0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31331, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31331, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"highvoltage\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a7190", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31354, - "line": 1038, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31367, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a7160", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31361, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31367, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57e18", - "kind": "EnumConstantDecl", - "name": "HIGH_VOLTAGE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a85d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31385, - "line": 1039, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31426, - "line": 1040, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7a8520", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31389, - "line": 1039, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31394, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a8508", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31391, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31391, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a84e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31391, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31391, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a71c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31389, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31389, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a84d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31394, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 31394, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a71e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31394, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 31394, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"iodelay\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a85c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31413, - "line": 1040, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31426, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7a8590", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31420, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31426, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56fa8", - "kind": "EnumConstantDecl", - "name": "IO_DELAY", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a9a00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31440, - "line": 1041, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31482, - "line": 1042, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7a9950", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31444, - "line": 1041, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31449, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a9938", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31446, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31446, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a9918", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31446, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31446, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a85f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31444, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31444, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a9900", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31449, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31449, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a8610", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31449, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31449, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"temp_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a99f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31469, - "line": 1042, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31482, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7a99c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31476, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31482, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57e70", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7aae30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31503, - "line": 1043, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31546, - "line": 1044, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aad80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31507, - "line": 1043, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31512, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7aad68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31509, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31509, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aad48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31509, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31509, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a9a20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31507, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31507, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7aad30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31512, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31512, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a9a40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31512, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31512, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpga\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7aae20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31533, - "line": 1044, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31546, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aadf0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31540, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31546, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57ec8", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGA", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ac260", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31568, - "line": 1045, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31614, - "line": 1046, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7ac1b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31572, - "line": 1045, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31577, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ac198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31574, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31574, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ac178", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31574, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31574, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7aae50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31572, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31572, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ac160", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31577, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 31577, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aae70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31577, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 31577, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpgaext\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ac250", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31601, - "line": 1046, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31614, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7ac220", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31608, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31614, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57f20", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGAEXT", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ad690", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31639, - "line": 1047, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31682, - "line": 1048, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7ad5e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31643, - "line": 1047, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31648, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ad5c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31645, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31645, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ad5a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31645, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31645, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ac280", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31643, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31643, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ad590", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31648, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31648, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ac2a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31648, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31648, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_10ge\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ad680", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31669, - "line": 1048, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31682, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7ad650", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31676, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31682, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57f78", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_10GE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7aeac0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31704, - "line": 1049, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31747, - "line": 1050, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aea10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31708, - "line": 1049, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31713, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ae9f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31710, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31710, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ae9d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31710, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31710, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ad6b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31708, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31708, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ae9c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31713, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31713, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ad6d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31713, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31713, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_dcdc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7aeab0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31734, - "line": 1050, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31747, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aea80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31741, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31747, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57fd0", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_DCDC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7afef0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31769, - "line": 1051, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31812, - "line": 1052, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7afe40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31773, - "line": 1051, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31778, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7afe28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7afe08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7aeae0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31773, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31773, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7afdf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31778, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31778, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aeb00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31778, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31778, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_sodl\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7afee0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31799, - "line": 1052, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31812, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7afeb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31806, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31812, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58028", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_SODL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b1320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31834, - "line": 1053, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31877, - "line": 1054, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7b1270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31838, - "line": 1053, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31843, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b1258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b1238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7aff10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31838, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31838, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b1220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31843, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31843, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aff30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31843, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31843, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_sodr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b1310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31864, - "line": 1054, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31877, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7b12e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31871, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31877, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58080", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_SODR", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b2750", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31899, - "line": 1055, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31944, - "line": 1056, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b26a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31903, - "line": 1055, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31908, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b2688", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31905, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31905, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b2668", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31905, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31905, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b1340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31903, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31903, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b2650", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31908, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31908, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b1360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31908, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31908, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpgafl\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b2740", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31931, - "line": 1056, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31944, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b2710", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31938, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31944, - "col": 22, - "tokLen": 17 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd580d8", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGA2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b3b80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31967, - "line": 1057, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32012, - "line": 1058, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b3ad0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31971, - "line": 1057, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31976, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b3ab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31973, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31973, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b3a98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31973, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31973, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b2770", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31971, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31971, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b3a80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31976, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31976, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b2790", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31976, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31976, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpgafr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b3b70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31999, - "line": 1058, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32012, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b3b40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32006, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32012, - "col": 22, - "tokLen": 17 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58130", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGA3", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b4fb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32035, - "line": 1059, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32081, - "line": 1060, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7b4f00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32039, - "line": 1059, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32044, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b4ee8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32041, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32041, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b4ec8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32041, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32041, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b3ba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32039, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32039, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b4eb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32044, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 32044, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b3bc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32044, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 32044, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"temp_slowadc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b4fa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32068, - "line": 1060, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32081, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7b4f70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32075, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32081, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd584e0", - "kind": "EnumConstantDecl", - "name": "SLOW_ADC_TEMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b55d8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 32100, - "line": 1061, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7b55c0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 32100, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7b5598", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 32106, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7b5578", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32106, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7b5570", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7b5540", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 32106, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7b5528", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7b5510", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7b54f0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7b54e8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7b54b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b5498", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32140, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 32140, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b5478", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32140, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 32140, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7b5460", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32119, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b4fe0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32119, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char[19]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown dac Index \"" - } - ] - }, - { - "id": "0x564d8e7b5010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32142, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7b5a50", - "kind": "FunctionDecl", - "loc": { - "offset": 32178, - "file": "ToString.cpp", - "line": 1064, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 32149, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 32583, - "line": 1078, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a8fe0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10powerIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::powerIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "inner": [ - { - "id": "0x564d8dd585f0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "decl": { - "id": "0x564d8dd58550", - "kind": "EnumDecl", - "name": "powerIndex" - } - } - ] - }, - { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "loc": { - "offset": 32206, - "line": 1064, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 32187, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 32206, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7bdb90", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 32209, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 32583, - "line": 1078, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7b7040", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32215, - "line": 1065, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32252, - "line": 1066, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b6f90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32219, - "line": 1065, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32224, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b6f78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32221, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32221, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b6f58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32221, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32221, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b5c38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32219, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32219, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b6f40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32224, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32224, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b5c58", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32224, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32224, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_a\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b7030", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32239, - "line": 1066, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32252, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b7000", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32246, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32252, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58610", - "kind": "EnumConstantDecl", - "name": "V_POWER_A", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b8470", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32267, - "line": 1067, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32304, - "line": 1068, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b83c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32271, - "line": 1067, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32276, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b83a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32273, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32273, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b8388", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32273, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32273, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b7060", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32271, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32271, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b8370", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32276, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32276, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b7080", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32276, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32276, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_b\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b8460", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32291, - "line": 1068, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32304, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b8430", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32298, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32304, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58668", - "kind": "EnumConstantDecl", - "name": "V_POWER_B", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b98a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32319, - "line": 1069, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32356, - "line": 1070, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b97f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32323, - "line": 1069, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32328, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b97d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32325, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32325, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b97b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32325, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32325, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b8490", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32323, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32323, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b97a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32328, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32328, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b84b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32328, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32328, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_c\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b9890", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32343, - "line": 1070, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32356, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b9860", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32350, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32356, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd586c0", - "kind": "EnumConstantDecl", - "name": "V_POWER_C", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bacf0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32371, - "line": 1071, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32408, - "line": 1072, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7bac40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32375, - "line": 1071, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32380, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bac28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32377, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32377, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bac08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32377, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32377, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b98c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32375, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32375, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7babf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32380, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32380, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b98e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32380, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32380, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_d\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bace0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32395, - "line": 1072, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32408, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7bacb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32402, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32408, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58718", - "kind": "EnumConstantDecl", - "name": "V_POWER_D", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bc120", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32423, - "line": 1073, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32461, - "line": 1074, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7bc070", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32427, - "line": 1073, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32432, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bc058", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32429, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32429, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bc038", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32429, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32429, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bad10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32427, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32427, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7bc020", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32432, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 32432, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bad30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32432, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 32432, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"v_io\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bc110", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32448, - "line": 1074, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32461, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7bc0e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32455, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32461, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58770", - "kind": "EnumConstantDecl", - "name": "V_POWER_IO", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bd550", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32477, - "line": 1075, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32517, - "line": 1076, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7bd4a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32481, - "line": 1075, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32486, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bd488", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bd468", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bc140", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32481, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32481, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7bd450", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32486, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 32486, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bc160", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32486, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 32486, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"v_chip\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bd540", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32504, - "line": 1076, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32517, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7bd510", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32511, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32517, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd587c8", - "kind": "EnumConstantDecl", - "name": "V_POWER_CHIP", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bdb78", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 32535, - "line": 1077, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7bdb60", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 32535, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7bdb38", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 32541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7bdb18", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7bdb10", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7bdae0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 32541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7bdac8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7bdab0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7bda90", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7bda88", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7bda50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bda38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32577, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 32577, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bda18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32577, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 32577, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7bda00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32554, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bd580", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32554, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown power Index \"" - } - ] - }, - { - "id": "0x564d8e7bd5b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32579, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7bdd60", - "kind": "FunctionDecl", - "loc": { - "offset": 32614, - "file": "ToString.cpp", - "line": 1080, - "col": 29, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 32586, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 32974, - "line": 1090, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a9570", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs9burstModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::burstMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "inner": [ - { - "id": "0x564d8dd59b10", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "decl": { - "id": "0x564d8dd59a68", - "kind": "EnumDecl", - "name": "burstMode" - } - } - ] - }, - { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "loc": { - "offset": 32642, - "line": 1080, - "col": 57, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 32623, - "col": 38, - "tokLen": 5 - }, - "end": { - "offset": 32642, - "col": 57, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7c3630", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 32645, - "col": 60, - "tokLen": 1 - }, - "end": { - "offset": 32974, - "line": 1090, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7bf360", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32651, - "line": 1081, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32699, - "line": 1082, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7bf2b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32655, - "line": 1081, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32660, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bf298", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32657, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32657, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bf278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32657, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32657, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bdf48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32655, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32655, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7bf260", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32660, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32660, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bdf68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32660, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32660, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"burst_internal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bf350", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32686, - "line": 1082, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32699, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7bf320", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32693, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32699, - "col": 22, - "tokLen": 14 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59b30", - "kind": "EnumConstantDecl", - "name": "BURST_INTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c0790", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32719, - "line": 1083, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32767, - "line": 1084, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7c06e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32723, - "line": 1083, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32728, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c06c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32725, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32725, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c06a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32725, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32725, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bf380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32723, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32723, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c0690", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32728, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32728, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bf3a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32728, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32728, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"burst_external\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c0780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32754, - "line": 1084, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32767, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7c0750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32761, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32767, - "col": 22, - "tokLen": 14 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59b88", - "kind": "EnumConstantDecl", - "name": "BURST_EXTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c1bc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32787, - "line": 1085, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32832, - "line": 1086, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c1b10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32791, - "line": 1085, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32796, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c1af8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32793, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32793, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c1ad8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32793, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32793, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c07b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32791, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32791, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c1ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32796, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32796, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c07d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32796, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32796, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"cw_internal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c1bb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32819, - "line": 1086, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32832, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c1b80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32826, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32832, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59be0", - "kind": "EnumConstantDecl", - "name": "CONTINUOUS_INTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c2ff0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32857, - "line": 1087, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32902, - "line": 1088, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c2f40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32861, - "line": 1087, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32866, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c2f28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32863, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32863, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c2f08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32863, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32863, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c1be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32861, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32861, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c2ef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32866, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32866, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c1c00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32866, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32866, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"cw_external\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c2fe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32889, - "line": 1088, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32902, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c2fb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32896, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32902, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59c38", - "kind": "EnumConstantDecl", - "name": "CONTINUOUS_EXTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c3618", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 32927, - "line": 1089, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7c3600", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 32927, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7c35d8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 32933, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7c35b8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32933, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c35b0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c3580", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 32933, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7c3568", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7c3550", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7c3530", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c3528", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c34f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c34d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32968, - "col": 46, - "tokLen": 1 - }, - "end": { - "offset": 32968, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c34b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32968, - "col": 46, - "tokLen": 1 - }, - "end": { - "offset": 32968, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7c34a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32946, - "col": 24, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c3020", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32946, - "col": 24, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char[20]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown burst mode \"" - } - ] - }, - { - "id": "0x564d8e7c3050", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32970, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7c37f0", - "kind": "FunctionDecl", - "loc": { - "offset": 33012, - "file": "ToString.cpp", - "line": 1092, - "col": 36, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 32977, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 33230, - "line": 1098, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a9b60", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16timingSourceTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingSourceType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "inner": [ - { - "id": "0x564d8dd59dc0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "decl": { - "id": "0x564d8dd59d18", - "kind": "EnumDecl", - "name": "timingSourceType" - } - } - ] - }, - { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "loc": { - "offset": 33040, - "line": 1092, - "col": 64, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 33021, - "col": 45, - "tokLen": 5 - }, - "end": { - "offset": 33040, - "col": 64, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7c6890", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 33043, - "col": 67, - "tokLen": 1 - }, - "end": { - "offset": 33230, - "line": 1098, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7c4de0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33049, - "line": 1093, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33091, - "line": 1094, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c4d30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33053, - "line": 1093, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33058, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c4d18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33055, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33055, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c4cf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33055, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33055, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c39d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33053, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33053, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c4ce0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33058, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33058, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c39f8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33058, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33058, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"internal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c4dd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33078, - "line": 1094, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33091, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c4da0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33085, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33091, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59de0", - "kind": "EnumConstantDecl", - "name": "TIMING_INTERNAL", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c6210", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33112, - "line": 1095, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33154, - "line": 1096, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c6160", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33116, - "line": 1095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33121, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c6148", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6128", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c4e00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33116, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33116, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c6110", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33121, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33121, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c4e20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33121, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33121, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"external\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c6200", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33141, - "line": 1096, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33154, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c61d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33148, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33154, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59e38", - "kind": "EnumConstantDecl", - "name": "TIMING_EXTERNAL", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c6878", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 33175, - "line": 1097, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7c6860", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 33175, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7c6838", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 33181, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7c6818", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33181, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c6810", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c67e0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 33181, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7c67c8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7c67b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7c6790", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c6788", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c6750", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c6738", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33224, - "col": 54, - "tokLen": 1 - }, - "end": { - "offset": 33224, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6718", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33224, - "col": 54, - "tokLen": 1 - }, - "end": { - "offset": 33224, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7c6700", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33194, - "col": 24, - "tokLen": 29 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6240", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33194, - "col": 24, - "tokLen": 29 - } - }, - "type": { - "qualType": "const char[28]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown timing source type \"" - } - ] - }, - { - "id": "0x564d8e7c6278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33226, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7c6a40", - "kind": "FunctionDecl", - "loc": { - "offset": 33263, - "file": "ToString.cpp", - "line": 1100, - "col": 31, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 33233, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 33673, - "line": 1114, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aa0f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11M3_GainCapsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::M3_GainCaps (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "inner": [ - { - "id": "0x564d8dd59f30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "decl": { - "id": "0x564d8dd59e90", - "kind": "EnumDecl", - "name": "M3_GainCaps" - } - } - ] - }, - { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "loc": { - "offset": 33291, - "line": 1100, - "col": 59, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 33272, - "col": 40, - "tokLen": 5 - }, - "end": { - "offset": 33291, - "col": 59, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7ceb60", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 33294, - "col": 62, - "tokLen": 1 - }, - "end": { - "offset": 33673, - "line": 1114, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7c8030", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33300, - "line": 1101, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33340, - "line": 1102, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7c7f80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33304, - "line": 1101, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33309, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c7f68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33306, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33306, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c7f48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33306, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33306, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c6c28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33304, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33304, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c7f30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33309, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33309, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6c48", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33309, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33309, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"C10pre\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c8020", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33327, - "line": 1102, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33340, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7c7ff0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33334, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33340, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59fd0", - "kind": "EnumConstantDecl", - "name": "M3_C10pre", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c9460", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33355, - "line": 1103, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33394, - "line": 1104, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7c93b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33359, - "line": 1103, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33364, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c9398", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33361, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33361, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c9378", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33361, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33361, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c8050", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33359, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33359, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c9360", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33364, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33364, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c8070", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33364, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33364, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"C15sh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c9450", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33381, - "line": 1104, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33394, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7c9420", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33388, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33394, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a0a8", - "kind": "EnumConstantDecl", - "name": "M3_C15sh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ca890", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33408, - "line": 1105, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33447, - "line": 1106, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ca7e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33412, - "line": 1105, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33417, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ca7c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33414, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33414, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ca7a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33414, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33414, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c9480", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33412, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33412, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ca790", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33417, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33417, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c94a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33417, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33417, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"C30sh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ca880", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33434, - "line": 1106, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33447, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ca850", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33441, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33447, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a180", - "kind": "EnumConstantDecl", - "name": "M3_C30sh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7cbcc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33461, - "line": 1107, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33500, - "line": 1108, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7cbc10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33465, - "line": 1107, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33470, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7cbbf8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33467, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33467, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cbbd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33467, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33467, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ca8b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33465, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33465, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7cbbc0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33470, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33470, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ca8d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33470, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33470, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"C50sh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7cbcb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33487, - "line": 1108, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33500, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7cbc80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33494, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33500, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a258", - "kind": "EnumConstantDecl", - "name": "M3_C50sh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7cd0f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33514, - "line": 1109, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33556, - "line": 1110, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e7cd040", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33518, - "line": 1109, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33523, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7cd028", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33520, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33520, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cd008", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33520, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33520, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7cbce0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33518, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33518, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ccff0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33523, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33523, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cbd00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33523, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33523, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"C225ACsh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7cd0e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33543, - "line": 1110, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33556, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e7cd0b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33550, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33556, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a330", - "kind": "EnumConstantDecl", - "name": "M3_C225ACsh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ce520", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33573, - "line": 1111, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33613, - "line": 1112, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7ce470", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33577, - "line": 1111, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33582, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ce458", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33579, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33579, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ce438", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33579, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33579, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7cd110", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33577, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33577, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ce420", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33582, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33582, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cd130", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33582, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33582, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"C15pre\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ce510", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33600, - "line": 1112, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33613, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7ce4e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33607, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33613, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a408", - "kind": "EnumConstantDecl", - "name": "M3_C15pre", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ceb48", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 33628, - "line": 1113, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ceb30", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 33628, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ceb08", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 33634, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7ceae8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33634, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ceae0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ceab0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 33634, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7cea98", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7cea80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7cea60", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7cea58", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7cea20", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7cea08", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33667, - "col": 44, - "tokLen": 1 - }, - "end": { - "offset": 33667, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ce9e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33667, - "col": 44, - "tokLen": 1 - }, - "end": { - "offset": 33667, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7ce9d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33647, - "col": 24, - "tokLen": 19 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ce550", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33647, - "col": 24, - "tokLen": 19 - } - }, - "type": { - "qualType": "const char[18]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown gain cap \"" - } - ] - }, - { - "id": "0x564d8e7ce580", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33669, - "col": 46, - "tokLen": 1 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7ced30", - "kind": "FunctionDecl", - "loc": { - "offset": 33707, - "file": "ToString.cpp", - "line": 1116, - "col": 32, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 33676, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 33990, - "line": 1126, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aa680", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12portPositionEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::portPosition (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "inner": [ - { - "id": "0x564d8dd5a590", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "decl": { - "id": "0x564d8dd5a4f0", - "kind": "EnumDecl", - "name": "portPosition" - } - } - ] - }, - { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "loc": { - "offset": 33735, - "line": 1116, - "col": 60, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 33716, - "col": 41, - "tokLen": 5 - }, - "end": { - "offset": 33735, - "col": 60, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7d45f0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 33738, - "col": 63, - "tokLen": 1 - }, - "end": { - "offset": 33990, - "line": 1126, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d0320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33744, - "line": 1117, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33782, - "line": 1118, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d0270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33748, - "line": 1117, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33753, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d0258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33750, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33750, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d0238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33750, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33750, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7cef18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33748, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33748, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d0220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33753, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 33753, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cef38", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33753, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 33753, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"left\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d0310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33769, - "line": 1118, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33782, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d02e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33776, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33782, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a5b0", - "kind": "EnumConstantDecl", - "name": "LEFT", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d1750", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33792, - "line": 1119, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33831, - "line": 1120, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7d16a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33796, - "line": 1119, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33801, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d1688", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33798, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33798, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d1668", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33798, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33798, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d0340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33796, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33796, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d1650", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33801, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33801, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d0360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33801, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33801, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"right\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d1740", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33818, - "line": 1120, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33831, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7d1710", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33825, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33831, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a608", - "kind": "EnumConstantDecl", - "name": "RIGHT", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d2b80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33842, - "line": 1121, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33879, - "line": 1122, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e7d2ad0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33846, - "line": 1121, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33851, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d2ab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33848, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33848, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d2a98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33848, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33848, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d1770", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33846, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33846, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d2a80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33851, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 33851, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d1790", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33851, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 33851, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"top\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d2b70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33866, - "line": 1122, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33879, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e7d2b40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33873, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33879, - "col": 22, - "tokLen": 3 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a660", - "kind": "EnumConstantDecl", - "name": "TOP", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d3fb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33888, - "line": 1123, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33928, - "line": 1124, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7d3f00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33892, - "line": 1123, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33897, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d3ee8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33894, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33894, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d3ec8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33894, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33894, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d2ba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33892, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33892, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d3eb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33897, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33897, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d2bc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33897, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33897, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"bottom\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d3fa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33915, - "line": 1124, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33928, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7d3f70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33922, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33928, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a6b8", - "kind": "EnumConstantDecl", - "name": "BOTTOM", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d45d8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 33940, - "line": 1125, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7d45c0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 33940, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d4598", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 33946, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7d4578", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33946, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7d4570", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7d4540", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 33946, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7d4528", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7d4510", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d44f0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7d44e8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7d44b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d4498", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33984, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 33984, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d4478", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33984, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 33984, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7d4460", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33959, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d3fe0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33959, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown port position \"" - } - ] - }, - { - "id": "0x564d8e7d4010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33986, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7d47b0", - "kind": "FunctionDecl", - "loc": { - "offset": 34030, - "file": "ToString.cpp", - "line": 1128, - "col": 38, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 33993, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 34453, - "line": 1139, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aac10", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18streamingInterfaceEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::streamingInterface (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "inner": [ - { - "id": "0x564d8dd5a950", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "decl": { - "id": "0x564d8dd5a8b0", - "kind": "EnumDecl", - "name": "streamingInterface" - } - } - ] - }, - { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "loc": { - "offset": 34058, - "line": 1128, - "col": 66, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 34039, - "col": 47, - "tokLen": 5 - }, - "end": { - "offset": 34058, - "col": 66, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7da3f0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 34061, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 34453, - "line": 1139, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d4a98", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 34067, - "line": 1129, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 34085, - "col": 23, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "loc": { - "offset": 34079, - "col": 17, - "tokLen": 2 - }, - "range": { - "begin": { - "offset": 34067, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 34084, - "col": 22, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7d4a68", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 34084, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 34084, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const basic_string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7d4a48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34084, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 34084, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d6050", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34091, - "line": 1130, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34158, - "line": 1131, - "col": 30, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d5578", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 34095, - "line": 1130, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34123, - "col": 37, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7d5400", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 34095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34105, - "col": 19, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d53d0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 34095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34097, - "col": 11, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6fb8", - "inner": [ - { - "id": "0x564d8e7d4ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34095, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7d4b48", - "kind": "CharacterLiteral", - "range": { - "begin": { - "offset": 34102, - "col": 16, - "tokLen": 3 - }, - "end": { - "offset": 34102, - "col": 16, - "tokLen": 3 - } - }, - "type": { - "qualType": "char" - }, - "valueCategory": "prvalue", - "value": 44 - }, - { - "id": "0x564d8e7d5448", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d5430", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 102107, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2991, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a00b0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d5560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34110, - "file": "ToString.cpp", - "line": 1130, - "col": 24, - "tokLen": 3 - }, - "end": { - "offset": 34123, - "col": 37, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7d5530", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34110, - "col": 24, - "tokLen": 3 - }, - "end": { - "offset": 34123, - "col": 37, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7d5fa8", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 34137, - "line": 1131, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34158, - "col": 30, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string" - }, - "valueCategory": "lvalue", - "inner": [ - { - "id": "0x564d8e7d5f78", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 34137, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34140, - "col": 12, - "tokLen": 5 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "erase", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6ac4e8", - "inner": [ - { - "id": "0x564d8e7d5598", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34137, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34137, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d5ef8", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34157, - "col": 29, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d5eb0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34149, - "col": 21, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6fb8", - "inner": [ - { - "id": "0x564d8e7d5ee0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34146, - "col": 18, - "tokLen": 2 - } - }, - "type": { - "qualType": "const std::basic_string" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d5620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34146, - "col": 18, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d56b8", - "kind": "CharacterLiteral", - "range": { - "begin": { - "offset": 34154, - "col": 26, - "tokLen": 3 - }, - "end": { - "offset": 34154, - "col": 26, - "tokLen": 3 - } - }, - "type": { - "qualType": "char" - }, - "valueCategory": "prvalue", - "value": 44 - }, - { - "id": "0x564d8e7d5f28", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d5430", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 102107, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2991, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a00b0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d6030", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d6018", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 76670, - "line": 2323, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 76670, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7d5ff8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 76670, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 76670, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d74b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34165, - "file": "ToString.cpp", - "line": 1132, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34224, - "line": 1133, - "col": 42, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d73e8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34169, - "line": 1132, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34175, - "col": 15, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d73d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34172, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34172, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d73b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34172, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34172, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d7380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34169, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34169, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d6070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34169, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34169, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d7398", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34175, - "col": 15, - "tokLen": 6 - }, - "end": { - "offset": 34175, - "col": 15, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d6090", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34175, - "col": 15, - "tokLen": 6 - }, - "end": { - "offset": 34175, - "col": 15, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"none\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d74a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34191, - "line": 1133, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34224, - "col": 42, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d7470", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34198, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34224, - "col": 42, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a9b0", - "kind": "EnumConstantDecl", - "name": "NONE", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d8910", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34234, - "line": 1134, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34292, - "line": 1135, - "col": 42, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7d8848", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34238, - "line": 1134, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34244, - "col": 15, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d8830", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34241, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34241, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d8810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34241, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34241, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d87e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34238, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34238, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d74d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34238, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34238, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d87f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34244, - "col": 15, - "tokLen": 5 - }, - "end": { - "offset": 34244, - "col": 15, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d74f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34244, - "col": 15, - "tokLen": 5 - }, - "end": { - "offset": 34244, - "col": 15, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"lll\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d8900", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34259, - "line": 1135, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34292, - "col": 42, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7d88d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34266, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34292, - "col": 42, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5aa88", - "kind": "EnumConstantDecl", - "name": "LOW_LATENCY_LINK", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d9d70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34314, - "line": 1136, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34374, - "line": 1137, - "col": 42, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7d9ca8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34318, - "line": 1136, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34324, - "col": 15, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d9c90", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34321, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34321, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d9c70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34321, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34321, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d9c40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34318, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34318, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d8930", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34318, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34318, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d9c58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34324, - "col": 15, - "tokLen": 7 - }, - "end": { - "offset": 34324, - "col": 15, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d8950", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34324, - "col": 15, - "tokLen": 7 - }, - "end": { - "offset": 34324, - "col": 15, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"10gbe\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d9d60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34341, - "line": 1137, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34374, - "col": 42, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7d9d30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34348, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34374, - "col": 42, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5ab60", - "kind": "EnumConstantDecl", - "name": "ETHERNET_10GB", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7da3d8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 34393, - "line": 1138, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7da3c0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 34393, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7da398", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 34399, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7da378", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34399, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7da370", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7da340", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 34399, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7da328", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7da310", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7da2f0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7da2e8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7da2b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7da298", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34447, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 34447, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7da278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34447, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 34447, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7da260", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34412, - "col": 24, - "tokLen": 34 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d9da0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34412, - "col": 24, - "tokLen": 34 - } - }, - "type": { - "qualType": "const char[33]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown streamingInterface type \"" - } - ] - }, - { - "id": "0x564d8e7d9dd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34449, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7da5c0", - "kind": "FunctionDecl", - "loc": { - "offset": 34488, - "file": "ToString.cpp", - "line": 1141, - "col": 33, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 34456, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 34678, - "line": 1147, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ab1a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs13vetoAlgorithmEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::vetoAlgorithm (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "inner": [ - { - "id": "0x564d8dd5ad30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "decl": { - "id": "0x564d8dd5ac90", - "kind": "EnumDecl", - "name": "vetoAlgorithm" - } - } - ] - }, - { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "loc": { - "offset": 34516, - "line": 1141, - "col": 61, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 34497, - "col": 42, - "tokLen": 5 - }, - "end": { - "offset": 34516, - "col": 61, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7dd640", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 34519, - "col": 64, - "tokLen": 1 - }, - "end": { - "offset": 34678, - "line": 1147, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7dbbd0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34525, - "line": 1142, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34563, - "line": 1143, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7dbb20", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34529, - "line": 1142, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34534, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7dbb08", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34531, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34531, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dbae8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34531, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34531, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7da7a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34529, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34529, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7dbad0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34534, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 34534, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7da7c8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34534, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 34534, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"hits\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7dbbc0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34550, - "line": 1143, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34563, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7dbb90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34557, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34563, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5ad50", - "kind": "EnumConstantDecl", - "name": "ALG_HITS", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7dd000", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34577, - "line": 1144, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34614, - "line": 1145, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7dcf50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34581, - "line": 1144, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34586, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7dcf38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34583, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34583, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dcf18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34583, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34583, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7dbbf0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34581, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34581, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7dcf00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34586, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 34586, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dbc10", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34586, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 34586, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"raw\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7dcff0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34601, - "line": 1145, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34614, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7dcfc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34608, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34614, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5ada8", - "kind": "EnumConstantDecl", - "name": "ALG_RAW", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7dd628", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 34627, - "line": 1146, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7dd610", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 34627, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7dd5e8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 34633, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7dd5c8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34633, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7dd5c0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7dd590", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 34633, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7dd578", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7dd560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7dd540", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7dd538", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7dd500", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7dd4e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34672, - "col": 50, - "tokLen": 1 - }, - "end": { - "offset": 34672, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dd4c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34672, - "col": 50, - "tokLen": 1 - }, - "end": { - "offset": 34672, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7dd4b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34646, - "col": 24, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dd030", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34646, - "col": 24, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char[24]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown veto algorithm \"" - } - ] - }, - { - "id": "0x564d8e7dd060", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34674, - "col": 52, - "tokLen": 1 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7dd7f0", - "kind": "FunctionDecl", - "loc": { - "offset": 34708, - "file": "ToString.cpp", - "line": 1149, - "col": 28, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 34681, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35134, - "line": 1163, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ab730", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8gainModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::gainMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "inner": [ - { - "id": "0x564d8dd5aea0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "decl": { - "id": "0x564d8dd5ae00", - "kind": "EnumDecl", - "name": "gainMode" - } - } - ] - }, - { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "loc": { - "offset": 34736, - "line": 1149, - "col": 56, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 34717, - "col": 37, - "tokLen": 5 - }, - "end": { - "offset": 34736, - "col": 56, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7e5910", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 34739, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 35134, - "line": 1163, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7dede0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34745, - "line": 1150, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34786, - "line": 1151, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7ded30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34749, - "line": 1150, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34754, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ded18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34751, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34751, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7decf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34751, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34751, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7dd9d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34749, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34749, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7dece0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34754, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 34754, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dd9f8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34754, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 34754, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"dynamic\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7dedd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34773, - "line": 1151, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34786, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7deda0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34780, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34786, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5aec0", - "kind": "EnumConstantDecl", - "name": "DYNAMIC", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e0210", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34799, - "line": 1152, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34846, - "line": 1153, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e0160", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34803, - "line": 1152, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34808, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e0148", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34805, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34805, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e0128", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34805, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34805, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7dee00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34803, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34803, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e0110", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34808, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34808, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dee20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34808, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34808, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"forceswitchg1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e0200", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34833, - "line": 1153, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34846, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e01d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34840, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34846, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5af18", - "kind": "EnumConstantDecl", - "name": "FORCE_SWITCH_G1", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e1640", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34867, - "line": 1154, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34914, - "line": 1155, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e1590", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34871, - "line": 1154, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34876, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e1578", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34873, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34873, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e1558", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34873, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34873, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e0230", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34871, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34871, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e1540", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34876, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34876, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e0250", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34876, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34876, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"forceswitchg2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e1630", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34901, - "line": 1155, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34914, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e1600", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34908, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34914, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5af70", - "kind": "EnumConstantDecl", - "name": "FORCE_SWITCH_G2", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e2a70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34935, - "line": 1156, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34974, - "line": 1157, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e29c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34939, - "line": 1156, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34944, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e29a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34941, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34941, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e2988", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34941, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34941, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e1660", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34939, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34939, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e2970", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34944, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34944, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e1680", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34944, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34944, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"fixg1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e2a60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34961, - "line": 1157, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34974, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e2a30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34968, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34974, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5afc8", - "kind": "EnumConstantDecl", - "name": "FIX_G1", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e3ea0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34986, - "line": 1158, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35025, - "line": 1159, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e3df0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34990, - "line": 1158, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34995, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e3dd8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e3db8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e2a90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34990, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34990, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e3da0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34995, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34995, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e2ab0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34995, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34995, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"fixg2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e3e90", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35012, - "line": 1159, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35025, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e3e60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35019, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35025, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b020", - "kind": "EnumConstantDecl", - "name": "FIX_G2", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e52d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35037, - "line": 1160, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35076, - "line": 1161, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e5220", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35041, - "line": 1160, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35046, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e5208", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35043, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35043, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e51e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35043, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35043, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e3ec0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35041, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35041, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e51d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35046, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35046, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e3ee0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35046, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35046, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"fixg0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e52c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35063, - "line": 1161, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35076, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e5290", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35070, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35076, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b078", - "kind": "EnumConstantDecl", - "name": "FIX_G0", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e58f8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35088, - "line": 1162, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7e58e0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35088, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7e58b8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35094, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7e5898", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35094, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e5890", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e5860", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35094, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7e5848", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7e5830", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7e5810", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e5808", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e57d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e57b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35128, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 35128, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e5798", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35128, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 35128, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7e5780", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35107, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e5300", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35107, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char[19]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown gain mode \"" - } - ] - }, - { - "id": "0x564d8e7e5330", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35130, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7e5ae0", - "kind": "FunctionDecl", - "loc": { - "offset": 35164, - "file": "ToString.cpp", - "line": 1165, - "col": 28, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35137, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35353, - "line": 1171, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3abcc0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8polarityEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::polarity (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "inner": [ - { - "id": "0x564d8dd5b170", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "decl": { - "id": "0x564d8dd5b0d0", - "kind": "EnumDecl", - "name": "polarity" - } - } - ] - }, - { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "loc": { - "offset": 35192, - "line": 1165, - "col": 56, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35173, - "col": 37, - "tokLen": 5 - }, - "end": { - "offset": 35192, - "col": 56, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7e8b40", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35195, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 35353, - "line": 1171, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7e70d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35201, - "line": 1166, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35238, - "line": 1167, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e7020", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35205, - "line": 1166, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35210, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e7008", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35207, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35207, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e6fe8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35207, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35207, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e5cc8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35205, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35205, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e6fd0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35210, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35210, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e5ce8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35210, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35210, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"pos\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e70c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35225, - "line": 1167, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35238, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e7090", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35232, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35238, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b190", - "kind": "EnumConstantDecl", - "name": "POSITIVE", - "type": { - "qualType": "slsDetectorDefs::polarity" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e8500", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35252, - "line": 1168, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35289, - "line": 1169, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e8450", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35256, - "line": 1168, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35261, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e8438", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35258, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35258, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e8418", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35258, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35258, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e70f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35256, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35256, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e8400", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35261, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35261, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e7110", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35261, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35261, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"neg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e84f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35276, - "line": 1169, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35289, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e84c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35283, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35289, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b1e8", - "kind": "EnumConstantDecl", - "name": "NEGATIVE", - "type": { - "qualType": "slsDetectorDefs::polarity" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e8b28", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35303, - "line": 1170, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7e8b10", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35303, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7e8ae8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35309, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7e8ac8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35309, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e8ac0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e8a90", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35309, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7e8a78", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7e8a60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7e8a40", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e8a38", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e8a00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e89e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35347, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 35347, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e89c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35347, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 35347, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7e89b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35322, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e8530", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35322, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown polarity mode \"" - } - ] - }, - { - "id": "0x564d8e7e8560", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35349, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7e8cf0", - "kind": "FunctionDecl", - "loc": { - "offset": 35392, - "file": "ToString.cpp", - "line": 1173, - "col": 37, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35356, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35591, - "line": 1179, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ac250", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs17timingInfoDecoderEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingInfoDecoder (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "inner": [ - { - "id": "0x564d8dd5b2e0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "decl": { - "id": "0x564d8dd5b240", - "kind": "EnumDecl", - "name": "timingInfoDecoder" - } - } - ] - }, - { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "loc": { - "offset": 35420, - "line": 1173, - "col": 65, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35401, - "col": 46, - "tokLen": 5 - }, - "end": { - "offset": 35420, - "col": 65, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7ebd90", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35423, - "col": 68, - "tokLen": 1 - }, - "end": { - "offset": 35591, - "line": 1179, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ea2e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35429, - "line": 1174, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35471, - "line": 1175, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ea230", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35433, - "line": 1174, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35438, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ea218", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35435, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35435, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ea1f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35435, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35435, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e8ed8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35433, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35433, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ea1e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35438, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35438, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e8ef8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35438, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35438, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"swissfel\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ea2d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35458, - "line": 1175, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35471, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ea2a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35465, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35471, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b300", - "kind": "EnumConstantDecl", - "name": "SWISSFEL", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7eb710", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35485, - "line": 1176, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35524, - "line": 1177, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7eb660", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35489, - "line": 1176, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35494, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7eb648", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35491, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35491, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7eb628", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35491, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35491, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ea300", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35489, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35489, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7eb610", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35494, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35494, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ea320", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35494, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35494, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"shine\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7eb700", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35511, - "line": 1177, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35524, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7eb6d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35518, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35524, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b358", - "kind": "EnumConstantDecl", - "name": "SHINE", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ebd78", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35535, - "line": 1178, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ebd60", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35535, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ebd38", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7ebd18", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ebd10", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ebce0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7ebcc8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7ebcb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7ebc90", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ebc88", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ebc50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ebc38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35585, - "col": 55, - "tokLen": 1 - }, - "end": { - "offset": 35585, - "col": 55, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ebc18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35585, - "col": 55, - "tokLen": 1 - }, - "end": { - "offset": 35585, - "col": 55, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7ebc00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35554, - "col": 24, - "tokLen": 30 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7eb740", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35554, - "col": 24, - "tokLen": 30 - } - }, - "type": { - "qualType": "const char[29]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown Timing Info Decoder \"" - } - ] - }, - { - "id": "0x564d8e7eb778", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35587, - "col": 57, - "tokLen": 1 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7ebf40", - "kind": "FunctionDecl", - "loc": { - "offset": 35627, - "file": "ToString.cpp", - "line": 1181, - "col": 34, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35594, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35820, - "line": 1187, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ac7e0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs14collectionModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::collectionMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "inner": [ - { - "id": "0x564d8dd5b450", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "decl": { - "id": "0x564d8dd5b3b0", - "kind": "EnumDecl", - "name": "collectionMode" - } - } - ] - }, - { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "loc": { - "offset": 35655, - "line": 1181, - "col": 62, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35636, - "col": 43, - "tokLen": 5 - }, - "end": { - "offset": 35655, - "col": 62, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7eefd0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35658, - "col": 65, - "tokLen": 1 - }, - "end": { - "offset": 35820, - "line": 1187, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ed530", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35664, - "line": 1182, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35702, - "line": 1183, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ed480", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35668, - "line": 1182, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35673, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ed468", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35670, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35670, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ed448", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35670, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35670, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ec128", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35668, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35668, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ed430", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35673, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 35673, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ec148", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35673, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 35673, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"hole\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ed520", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35689, - "line": 1183, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35702, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ed4f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35696, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35702, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b470", - "kind": "EnumConstantDecl", - "name": "HOLE", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ee960", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35712, - "line": 1184, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35754, - "line": 1185, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ee8b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35716, - "line": 1184, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35721, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ee898", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35718, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35718, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ee878", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35718, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35718, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ed550", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35716, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35716, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ee860", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35721, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35721, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ed570", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35721, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35721, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"electron\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ee950", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35741, - "line": 1185, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35754, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ee920", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35748, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35754, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b4c8", - "kind": "EnumConstantDecl", - "name": "ELECTRON", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7eefb8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35768, - "line": 1186, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7eefa0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35768, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7eef78", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35774, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7eef58", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35774, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7eef50", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7eef20", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35774, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7eef08", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7eeef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7eeed0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7eeec8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7eee90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7eee78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35814, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 35814, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7eee58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35814, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 35814, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7eee40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35787, - "col": 24, - "tokLen": 26 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ee990", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35787, - "col": 24, - "tokLen": 26 - } - }, - "type": { - "qualType": "const char[25]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown collection mode \"" - } - ] - }, - { - "id": "0x564d8e7ee9c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35816, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7ef130", - "kind": "FunctionDecl", - "loc": { - "offset": 35843, - "file": "ToString.cpp", - "line": 1189, - "col": 21, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35823, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 36272, - "line": 1198, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ad740", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIhEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint8_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned char" - }, - "inner": [ - { - "id": "0x564d8c93dc50", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned char" - } - } - ] - }, - { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "loc": { - "offset": 35871, - "line": 1189, - "col": 49, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35852, - "col": 30, - "tokLen": 5 - }, - "end": { - "offset": 35871, - "col": 49, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f4130", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35874, - "col": 52, - "tokLen": 1 - }, - "end": { - "offset": 36272, - "line": 1198, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f2e20", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 35880, - "line": 1190, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35934, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ef300", - "kind": "VarDecl", - "loc": { - "offset": 35884, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 35880, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35932, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f2df0", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35932, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2d90", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35920, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f2c50", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35902, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c20", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35893, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7ef368", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35891, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f2c80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35898, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 35898, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ef400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35898, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 35898, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f2cb0", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f2d78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35907, - "file": "ToString.cpp", - "line": 1190, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 35920, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f2d48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35907, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 35920, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f2db0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 35927, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 35927, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f2dd0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 35932, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 35932, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f3090", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 35940, - "line": 1191, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35979, - "col": 44, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "loc": { - "offset": 35944, - "col": 9, - "tokLen": 5 - }, - "range": { - "begin": { - "offset": 35940, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35978, - "col": 43, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "value", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f3028", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 35952, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 35978, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f3010", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35952, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 35957, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f2f78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35952, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 35957, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f2f28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35962, - "col": 27, - "tokLen": 1 - }, - "end": { - "offset": 35962, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f3060", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35965, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 35965, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f2f48", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 35965, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 35965, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f3078", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35974, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 35974, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f2f58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35974, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 35974, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef300", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4070", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35985, - "line": 1192, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 36230, - "line": 1196, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f3450", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 35989, - "line": 1192, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36086, - "line": 1193, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7f3288", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 35989, - "line": 1192, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36031, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "<", - "inner": [ - { - "id": "0x564d8e7f3258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35989, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 35989, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f30a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35989, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 35989, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f3270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36031, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f3238", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36031, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned char" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f3220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36027, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f31f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36027, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cad2760", - "kind": "CXXMethodDecl", - "name": "min", - "type": { - "qualType": "unsigned char () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f3430", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36044, - "line": 1193, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36086, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": ">", - "inner": [ - { - "id": "0x564d8e7f3400", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36044, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36044, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f32a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36044, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36044, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f3418", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36086, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f33e0", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36086, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned char" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f33c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36082, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f3398", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36082, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cad2838", - "kind": "CXXMethodDecl", - "name": "max", - "type": { - "qualType": "unsigned char () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4058", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36089, - "col": 54, - "tokLen": 1 - }, - "end": { - "offset": 36230, - "line": 1196, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4040", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 36099, - "line": 1194, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7f4028", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 36099, - "line": 1194, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f4000", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 36105, - "line": 1194, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7f3fe0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36105, - "line": 1194, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f3fd8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f3fa8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 36105, - "line": 1194, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7f3f90", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7f3f78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f3f58", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f3f50", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f3f18", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f3f00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36158, - "line": 1194, - "col": 68, - "tokLen": 1 - }, - "end": { - "offset": 36158, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(basic_string, allocator> &&, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f3ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36158, - "col": 68, - "tokLen": 1 - }, - "end": { - "offset": 36158, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dda7ec0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7f3eb0", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "xvalue", - "storageDuration": "full expression", - "inner": [ - { - "id": "0x564d8e7f3a30", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f3a28", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f39f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f39d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36154, - "col": 64, - "tokLen": 1 - }, - "end": { - "offset": 36154, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f39b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36154, - "col": 64, - "tokLen": 1 - }, - "end": { - "offset": 36154, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7f39a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36118, - "col": 28, - "tokLen": 35 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f34e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36118, - "col": 28, - "tokLen": 35 - } - }, - "type": { - "qualType": "const char[34]" - }, - "valueCategory": "lvalue", - "value": "\"Cannot scan uint8_t from string '\"" - } - ] - }, - { - "id": "0x564d8e7f3520", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36156, - "col": 66, - "tokLen": 1 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f3ec8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36187, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f3a50", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36187, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36187, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char[35]" - }, - "valueCategory": "lvalue", - "value": "\"'. Value must be in range 0 - 255.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4120", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 36236, - "line": 1197, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 36269, - "col": 38, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f40f0", - "kind": "CXXStaticCastExpr", - "range": { - "begin": { - "offset": 36243, - "col": 12, - "tokLen": 11 - }, - "end": { - "offset": 36269, - "col": 38, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned char", - "qualType": "uint8_t", - "typeAliasDeclId": "0x564d8cb58398" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f40d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36264, - "col": 33, - "tokLen": 5 - }, - "end": { - "offset": 36264, - "col": 33, - "tokLen": 5 - } - }, - "type": { - "desugaredQualType": "unsigned char", - "qualType": "uint8_t", - "typeAliasDeclId": "0x564d8cb58398" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f40c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36264, - "col": 33, - "tokLen": 5 - }, - "end": { - "offset": 36264, - "col": 33, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f4090", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36264, - "col": 33, - "tokLen": 5 - }, - "end": { - "offset": 36264, - "col": 33, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7f42a0", - "kind": "FunctionDecl", - "loc": { - "offset": 36296, - "file": "ToString.cpp", - "line": 1200, - "col": 22, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 36275, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 36731, - "line": 1209, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3adc50", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToItEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint16_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned short" - }, - "inner": [ - { - "id": "0x564d8c93dc70", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned short" - } - } - ] - }, - { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "loc": { - "offset": 36324, - "line": 1200, - "col": 50, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 36305, - "col": 31, - "tokLen": 5 - }, - "end": { - "offset": 36324, - "col": 50, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f61b0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36327, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 36731, - "line": 1209, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4fa8", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36333, - "line": 1201, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36387, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4470", - "kind": "VarDecl", - "loc": { - "offset": 36337, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 36333, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36385, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f4f78", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36385, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f4f18", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36373, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f4df0", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36355, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f4dc0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36346, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f44d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36344, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f4e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36351, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36351, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f4570", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36351, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36351, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f4e38", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4f00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36360, - "file": "ToString.cpp", - "line": 1201, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36373, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f4ed0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36360, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36373, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f4f38", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36380, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 36380, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f4f58", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36385, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 36385, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f51b0", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36393, - "line": 1202, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36432, - "col": 44, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "loc": { - "offset": 36397, - "col": 9, - "tokLen": 5 - }, - "range": { - "begin": { - "offset": 36393, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36431, - "col": 43, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "value", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f5148", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36405, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36431, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f5130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36405, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36410, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5100", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36405, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36410, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f50b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36415, - "col": 27, - "tokLen": 1 - }, - "end": { - "offset": 36415, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f5180", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36418, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 36418, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f50d0", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 36418, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 36418, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f5198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36427, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 36427, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f50e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36427, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 36427, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4470", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f60f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 36438, - "line": 1203, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 36688, - "line": 1207, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f5560", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36442, - "line": 1203, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36541, - "line": 1204, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7f5398", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36442, - "line": 1203, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36485, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "<", - "inner": [ - { - "id": "0x564d8e7f5368", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36442, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36442, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f51c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36442, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36442, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f5380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36485, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f5348", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36485, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned short" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f5330", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36481, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5300", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36481, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cbf64e0", - "kind": "CXXMethodDecl", - "name": "min", - "type": { - "qualType": "unsigned short () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f5540", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36498, - "line": 1204, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36541, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": ">", - "inner": [ - { - "id": "0x564d8e7f5510", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36498, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36498, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f53b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36498, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36498, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f5528", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36541, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f54f0", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36541, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned short" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f54d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36537, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f54a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36537, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cbf65b8", - "kind": "CXXMethodDecl", - "name": "max", - "type": { - "qualType": "unsigned short () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f60d8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36544, - "col": 55, - "tokLen": 1 - }, - "end": { - "offset": 36688, - "line": 1207, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f60c0", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 36554, - "line": 1205, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7f60a8", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 36554, - "line": 1205, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f6080", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 36560, - "line": 1205, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7f6060", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36560, - "line": 1205, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f6058", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f6028", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 36560, - "line": 1205, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7f6010", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7f5ff8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f5fd8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f5fd0", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f5f98", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f5f80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36614, - "line": 1205, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 36614, - "col": 69, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(basic_string, allocator> &&, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5f60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36614, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 36614, - "col": 69, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dda7ec0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7f5f30", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "xvalue", - "storageDuration": "full expression", - "inner": [ - { - "id": "0x564d8e7f5ab0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f5aa8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f5a70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f5a58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36610, - "col": 65, - "tokLen": 1 - }, - "end": { - "offset": 36610, - "col": 65, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5a38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36610, - "col": 65, - "tokLen": 1 - }, - "end": { - "offset": 36610, - "col": 65, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7f5a20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36573, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5590", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36573, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char[35]" - }, - "valueCategory": "lvalue", - "value": "\"Cannot scan uint16_t from string '\"" - } - ] - }, - { - "id": "0x564d8e7f55d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36612, - "col": 67, - "tokLen": 1 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f5f48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - }, - "end": { - "offset": 36643, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5ad0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36643, - "col": 28, - "tokLen": 38 - }, - "end": { - "offset": 36643, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "qualType": "const char[37]" - }, - "valueCategory": "lvalue", - "value": "\"'. Value must be in range 0 - 65535.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f61a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 36694, - "line": 1208, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 36728, - "col": 39, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f6170", - "kind": "CXXStaticCastExpr", - "range": { - "begin": { - "offset": 36701, - "col": 12, - "tokLen": 11 - }, - "end": { - "offset": 36728, - "col": 39, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned short", - "qualType": "uint16_t", - "typeAliasDeclId": "0x564d8cb58400" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f6158", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36723, - "col": 34, - "tokLen": 5 - }, - "end": { - "offset": 36723, - "col": 34, - "tokLen": 5 - } - }, - "type": { - "desugaredQualType": "unsigned short", - "qualType": "uint16_t", - "typeAliasDeclId": "0x564d8cb58400" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f6140", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36723, - "col": 34, - "tokLen": 5 - }, - "end": { - "offset": 36723, - "col": 34, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f6110", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36723, - "col": 34, - "tokLen": 5 - }, - "end": { - "offset": 36723, - "col": 34, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7f6320", - "kind": "FunctionDecl", - "loc": { - "offset": 36755, - "file": "ToString.cpp", - "line": 1211, - "col": 22, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 36734, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 36889, - "line": 1214, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ae160", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIjEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint32_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned int" - }, - "inner": [ - { - "id": "0x564d8c93dc90", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned int" - } - } - ] - }, - { - "id": "0x564d8e7f6250", - "kind": "ParmVarDecl", - "loc": { - "offset": 36783, - "line": 1211, - "col": 50, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 36764, - "col": 31, - "tokLen": 5 - }, - "end": { - "offset": 36783, - "col": 50, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f7238", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36786, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 36889, - "line": 1214, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f7028", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36792, - "line": 1212, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36846, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f64f0", - "kind": "VarDecl", - "loc": { - "offset": 36796, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 36792, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36844, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f6ff8", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36844, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f6f98", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36832, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f6e70", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36814, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f6e40", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36805, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f6558", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36803, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f6250", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f6ea0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36810, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36810, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f65f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36810, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36810, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f6eb8", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f6f80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36819, - "file": "ToString.cpp", - "line": 1212, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36832, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f6f50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36819, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36832, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f6fb8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36839, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 36839, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f6fd8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36844, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 36844, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f7228", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 36852, - "line": 1213, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 36886, - "col": 39, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f7210", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36886, - "col": 39, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned int", - "qualType": "uint32_t", - "typeAliasDeclId": "0x564d8cb58468" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f71a8", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36886, - "col": 39, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned long" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f7190", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36864, - "col": 17, - "tokLen": 5 - } - }, - "type": { - "qualType": "unsigned long (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f7100", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36864, - "col": 17, - "tokLen": 5 - } - }, - "type": { - "qualType": "unsigned long (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6c7648", - "kind": "FunctionDecl", - "name": "stoul", - "type": { - "qualType": "unsigned long (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f70b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36870, - "col": 23, - "tokLen": 1 - }, - "end": { - "offset": 36870, - "col": 23, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f6250", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f71e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36873, - "col": 26, - "tokLen": 7 - }, - "end": { - "offset": 36873, - "col": 26, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f70d0", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 36873, - "col": 26, - "tokLen": 7 - }, - "end": { - "offset": 36873, - "col": 26, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f71f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36882, - "col": 35, - "tokLen": 4 - }, - "end": { - "offset": 36882, - "col": 35, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f70e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36882, - "col": 35, - "tokLen": 4 - }, - "end": { - "offset": 36882, - "col": 35, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f64f0", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7f7390", - "kind": "FunctionDecl", - "loc": { - "offset": 36913, - "file": "ToString.cpp", - "line": 1216, - "col": 22, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 36892, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 37048, - "line": 1219, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ae630", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToImEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned long" - }, - "inner": [ - { - "id": "0x564d8c93dcb0", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned long" - } - } - ] - }, - { - "id": "0x564d8e7f72c8", - "kind": "ParmVarDecl", - "loc": { - "offset": 36941, - "line": 1216, - "col": 50, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 36922, - "col": 31, - "tokLen": 5 - }, - "end": { - "offset": 36941, - "col": 50, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f82a8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36944, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 37048, - "line": 1219, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f8098", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36950, - "line": 1217, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37004, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f7560", - "kind": "VarDecl", - "loc": { - "offset": 36954, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 36950, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37002, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f8068", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37002, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f8008", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36990, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f7ee0", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36972, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f7eb0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36963, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f75c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36961, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f72c8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f7f10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36968, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36968, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f7660", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36968, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36968, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f7f28", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f7ff0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36977, - "file": "ToString.cpp", - "line": 1217, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36990, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f7fc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36977, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36990, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f8028", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36997, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 36997, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f8048", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37002, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 37002, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f8298", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37010, - "line": 1218, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 37045, - "col": 40, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f8280", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37045, - "col": 40, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "uint64_t", - "typeAliasDeclId": "0x564d8cb584d0" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f8218", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37045, - "col": 40, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned long long" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f8200", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37022, - "col": 17, - "tokLen": 6 - } - }, - "type": { - "qualType": "unsigned long long (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f8170", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37022, - "col": 17, - "tokLen": 6 - } - }, - "type": { - "qualType": "unsigned long long (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6c97c8", - "kind": "FunctionDecl", - "name": "stoull", - "type": { - "qualType": "unsigned long long (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f8120", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37029, - "col": 24, - "tokLen": 1 - }, - "end": { - "offset": 37029, - "col": 24, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f72c8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f8250", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37032, - "col": 27, - "tokLen": 7 - }, - "end": { - "offset": 37032, - "col": 27, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f8140", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 37032, - "col": 27, - "tokLen": 7 - }, - "end": { - "offset": 37032, - "col": 27, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f8268", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37041, - "col": 36, - "tokLen": 4 - }, - "end": { - "offset": 37041, - "col": 36, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f8150", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37041, - "col": 36, - "tokLen": 4 - }, - "end": { - "offset": 37041, - "col": 36, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f7560", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7f8408", - "kind": "FunctionDecl", - "loc": { - "offset": 37067, - "file": "ToString.cpp", - "line": 1221, - "col": 17, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 37051, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 37200, - "line": 1224, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aeb48", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIiEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "int" - }, - "inner": [ - { - "id": "0x564d8c93dbf0", - "kind": "BuiltinType", - "type": { - "qualType": "int" - } - } - ] - }, - { - "id": "0x564d8e7f8338", - "kind": "ParmVarDecl", - "loc": { - "offset": 37095, - "line": 1221, - "col": 45, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37076, - "col": 26, - "tokLen": 5 - }, - "end": { - "offset": 37095, - "col": 45, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f92b0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37098, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 37200, - "line": 1224, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9118", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 37104, - "line": 1222, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37158, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f85e0", - "kind": "VarDecl", - "loc": { - "offset": 37108, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 37104, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37156, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f90e8", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37156, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f9088", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37144, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f8f60", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37126, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f8f30", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37117, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f8648", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37115, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f8338", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f8f90", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37122, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 37122, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f86e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37122, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 37122, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f8fa8", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f9070", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37131, - "file": "ToString.cpp", - "line": 1222, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 37144, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f9040", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37131, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 37144, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f90a8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37151, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 37151, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f90c8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37156, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 37156, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f92a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37164, - "line": 1223, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 37197, - "col": 38, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9238", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37171, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37197, - "col": 38, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f9220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37171, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37176, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f91f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37171, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37176, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f91a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37181, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 37181, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f8338", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f9270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37184, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 37184, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f91c0", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 37184, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 37184, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f9288", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37193, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 37193, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f91d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37193, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 37193, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f85e0", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7f9410", - "kind": "FunctionDecl", - "loc": { - "offset": 37220, - "file": "ToString.cpp", - "line": 1226, - "col": 18, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 37203, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 37304, - "line": 1228, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3af020", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIbEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "bool (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "bool" - }, - "inner": [ - { - "id": "0x564d8c93db70", - "kind": "BuiltinType", - "type": { - "qualType": "bool" - } - } - ] - }, - { - "id": "0x564d8e7f9340", - "kind": "ParmVarDecl", - "loc": { - "offset": 37248, - "line": 1226, - "col": 46, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37229, - "col": 27, - "tokLen": 5 - }, - "end": { - "offset": 37248, - "col": 46, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f97b8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37251, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 37304, - "line": 1228, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f97a8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37257, - "line": 1227, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 37301, - "col": 49, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9778", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37264, - "col": 12, - "tokLen": 8 - }, - "end": { - "offset": 37301, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f9760", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37264, - "col": 12, - "tokLen": 8 - }, - "end": { - "offset": 37264, - "col": 12, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool (*)(const std::string &, defs::boolFormat)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f96d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37264, - "col": 12, - "tokLen": 8 - }, - "end": { - "offset": 37264, - "col": 12, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3af5f0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - } - } - } - ] - }, - { - "id": "0x564d8e7f9628", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37273, - "col": 21, - "tokLen": 1 - }, - "end": { - "offset": 37273, - "col": 21, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9340", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f9698", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37276, - "col": 24, - "tokLen": 4 - }, - "end": { - "offset": 37294, - "col": 42, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74f70", - "kind": "EnumConstantDecl", - "name": "OneZero", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7f99d0", - "kind": "FunctionDecl", - "loc": { - "offset": 37312, - "file": "ToString.cpp", - "line": 1230, - "col": 6, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 37307, - "col": 1, - "tokLen": 4 - }, - "end": { - "offset": 38192, - "line": 1260, - "col": 1, - "tokLen": 1 - } - }, - "isUsed": true, - "previousDecl": "0x564d8e3af5f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN15slsDetectorDefs10boolFormatE", - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - }, - "inner": [ - { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "loc": { - "offset": 37340, - "line": 1230, - "col": 34, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37321, - "col": 15, - "tokLen": 5 - }, - "end": { - "offset": 37340, - "col": 34, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f98f0", - "kind": "ParmVarDecl", - "loc": { - "offset": 37360, - "col": 54, - "tokLen": 6 - }, - "range": { - "begin": { - "offset": 37343, - "col": 37, - "tokLen": 4 - }, - "end": { - "offset": 37360, - "col": 54, - "tokLen": 6 - } - }, - "isUsed": true, - "name": "format", - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - } - }, - { - "id": "0x564d8e7ff738", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37368, - "col": 62, - "tokLen": 1 - }, - "end": { - "offset": 38192, - "line": 1260, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9ad8", - "kind": "SwitchStmt", - "range": { - "begin": { - "offset": 37374, - "line": 1231, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 38190, - "line": 1259, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37382, - "line": 1231, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37382, - "col": 13, - "tokLen": 6 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f9aa8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37382, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37382, - "col": 13, - "tokLen": 6 - } - }, - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f9a88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37382, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37382, - "col": 13, - "tokLen": 6 - } - }, - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f98f0", - "kind": "ParmVarDecl", - "name": "format", - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ff708", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37390, - "col": 21, - "tokLen": 1 - }, - "end": { - "offset": 38190, - "line": 1259, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9bb8", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37396, - "line": 1232, - "col": 5, - "tokLen": 4 - }, - "end": { - "offset": 37615, - "line": 1238, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9b98", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37401, - "line": 1232, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37419, - "col": 28, - "tokLen": 9 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0", - "inner": [ - { - "id": "0x564d8e7f9b80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37401, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37419, - "col": 28, - "tokLen": 9 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f9b50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37401, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37419, - "col": 28, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74ec0", - "kind": "EnumConstantDecl", - "name": "TrueFalse", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7fc570", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37430, - "col": 39, - "tokLen": 1 - }, - "end": { - "offset": 37615, - "line": 1238, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7fafb8", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37440, - "line": 1233, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37476, - "line": 1234, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7faf60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37444, - "line": 1233, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37449, - "col": 18, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7faf48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37446, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37446, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7faf28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37446, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37446, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7f9be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37444, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37444, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7faf10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37449, - "col": 18, - "tokLen": 6 - }, - "end": { - "offset": 37449, - "col": 18, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f9c00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37449, - "col": 18, - "tokLen": 6 - }, - "end": { - "offset": 37449, - "col": 18, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"true\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fafa8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37469, - "line": 1234, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37476, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7faf98", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37476, - "col": 20, - "tokLen": 4 - }, - "end": { - "offset": 37476, - "col": 20, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": true - } - ] - } - ] - }, - { - "id": "0x564d8e7fc388", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37490, - "line": 1235, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37527, - "line": 1236, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7fc330", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37494, - "line": 1235, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37499, - "col": 18, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7fc318", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37496, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37496, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fc2f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37496, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37496, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7fafd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37494, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37494, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7fc2e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37499, - "col": 18, - "tokLen": 7 - }, - "end": { - "offset": 37499, - "col": 18, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7faff8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37499, - "col": 18, - "tokLen": 7 - }, - "end": { - "offset": 37499, - "col": 18, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"false\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fc378", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37520, - "line": 1236, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37527, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7fc368", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37527, - "col": 20, - "tokLen": 5 - }, - "end": { - "offset": 37527, - "col": 20, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": false - } - ] - } - ] - }, - { - "id": "0x564d8e7fc558", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 37542, - "line": 1237, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7fc540", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 37542, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7fc518", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 37548, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7fc4f8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 37548, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7fc4f0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7fc4c0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 37548, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7fc4a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37561, - "col": 28, - "tokLen": 47 - }, - "end": { - "offset": 37561, - "col": 28, - "tokLen": 47 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fc420", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37561, - "col": 28, - "tokLen": 47 - }, - "end": { - "offset": 37561, - "col": 28, - "tokLen": 47 - } - }, - "type": { - "qualType": "const char[46]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean. Expecting 'true' or 'false'.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7fc650", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37621, - "line": 1239, - "col": 5, - "tokLen": 4 - }, - "end": { - "offset": 37828, - "line": 1245, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7fc630", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37626, - "line": 1239, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37644, - "col": 28, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "1", - "inner": [ - { - "id": "0x564d8e7fc618", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37626, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37644, - "col": 28, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7fc5e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37626, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37644, - "col": 28, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74f18", - "kind": "EnumConstantDecl", - "name": "OnOff", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7fef78", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37651, - "col": 35, - "tokLen": 1 - }, - "end": { - "offset": 37828, - "line": 1245, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7fda28", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37661, - "line": 1240, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37695, - "line": 1241, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7fd9d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37665, - "line": 1240, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37670, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7fd9b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37667, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37667, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fd998", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37667, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37667, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7fc678", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37665, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37665, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7fd980", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37670, - "col": 18, - "tokLen": 4 - }, - "end": { - "offset": 37670, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fc698", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37670, - "col": 18, - "tokLen": 4 - }, - "end": { - "offset": 37670, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"on\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fda18", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37688, - "line": 1241, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37695, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7fda08", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37695, - "col": 20, - "tokLen": 4 - }, - "end": { - "offset": 37695, - "col": 20, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": true - } - ] - } - ] - }, - { - "id": "0x564d8e7fedf8", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37709, - "line": 1242, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37744, - "line": 1243, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7feda0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37713, - "line": 1242, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37718, - "col": 18, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7fed88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37715, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37715, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fed68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37715, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37715, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7fda48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37713, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37713, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7fed50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37718, - "col": 18, - "tokLen": 5 - }, - "end": { - "offset": 37718, - "col": 18, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fda68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37718, - "col": 18, - "tokLen": 5 - }, - "end": { - "offset": 37718, - "col": 18, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"off\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fede8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37737, - "line": 1243, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37744, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7fedd8", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37744, - "col": 20, - "tokLen": 5 - }, - "end": { - "offset": 37744, - "col": 20, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": false - } - ] - } - ] - }, - { - "id": "0x564d8e7fef60", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 37759, - "line": 1244, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7fef48", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 37759, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7fef20", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 37765, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7fef00", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 37765, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7feef8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7feec8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 37765, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7feeb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37778, - "col": 28, - "tokLen": 43 - }, - "end": { - "offset": 37778, - "col": 28, - "tokLen": 43 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fee28", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37778, - "col": 28, - "tokLen": 43 - }, - "end": { - "offset": 37778, - "col": 28, - "tokLen": 43 - } - }, - "type": { - "qualType": "const char[42]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean. Expecting 'on' or 'off'.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7ff058", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37834, - "line": 1246, - "col": 5, - "tokLen": 4 - }, - "end": { - "offset": 38116, - "line": 1256, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff038", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37839, - "line": 1246, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37857, - "col": 28, - "tokLen": 7 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "2", - "inner": [ - { - "id": "0x564d8e7ff020", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37839, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37857, - "col": 28, - "tokLen": 7 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7feff0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37839, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37857, - "col": 28, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74f70", - "kind": "EnumConstantDecl", - "name": "OneZero", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ff580", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37866, - "col": 37, - "tokLen": 1 - }, - "end": { - "offset": 38116, - "line": 1256, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff258", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 37876, - "line": 1247, - "col": 9, - "tokLen": 3 - }, - "end": { - "offset": 37909, - "col": 42, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff098", - "kind": "VarDecl", - "loc": { - "offset": 37880, - "col": 13, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37876, - "col": 9, - "tokLen": 3 - }, - "end": { - "offset": 37908, - "col": 41, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "i", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7ff208", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37884, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 37908, - "col": 41, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ff1f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37884, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 37889, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ff1c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37884, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 37889, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7ff170", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37894, - "col": 27, - "tokLen": 1 - }, - "end": { - "offset": 37894, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ff240", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37897, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 37897, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7ff190", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 37897, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 37897, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7ff1a0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37906, - "col": 39, - "tokLen": 2 - }, - "end": { - "offset": 37906, - "col": 39, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7ff2a8", - "kind": "SwitchStmt", - "range": { - "begin": { - "offset": 37919, - "line": 1248, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 38110, - "line": 1255, - "col": 9, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff290", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37927, - "line": 1248, - "col": 17, - "tokLen": 1 - }, - "end": { - "offset": 37927, - "col": 17, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7ff270", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37927, - "col": 17, - "tokLen": 1 - }, - "end": { - "offset": 37927, - "col": 17, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ff098", - "kind": "VarDecl", - "name": "i", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7ff558", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37930, - "col": 20, - "tokLen": 1 - }, - "end": { - "offset": 38110, - "line": 1255, - "col": 9, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff310", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37940, - "line": 1249, - "col": 9, - "tokLen": 4 - }, - "end": { - "offset": 37967, - "line": 1250, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7ff2f0", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37945, - "line": 1249, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37945, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0", - "inner": [ - { - "id": "0x564d8e7ff2d0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37945, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37945, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - }, - { - "id": "0x564d8e7ff348", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37960, - "line": 1250, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37967, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7ff338", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37967, - "col": 20, - "tokLen": 5 - }, - "end": { - "offset": 37967, - "col": 20, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": false - } - ] - } - ] - }, - { - "id": "0x564d8e7ff398", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37982, - "line": 1251, - "col": 9, - "tokLen": 4 - }, - "end": { - "offset": 38009, - "line": 1252, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ff378", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37987, - "line": 1251, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37987, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "1", - "inner": [ - { - "id": "0x564d8e7ff358", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37987, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37987, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "1" - } - ] - }, - { - "id": "0x564d8e7ff3d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 38002, - "line": 1252, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 38009, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ff3c0", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 38009, - "col": 20, - "tokLen": 4 - }, - "end": { - "offset": 38009, - "col": 20, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": true - } - ] - } - ] - }, - { - "id": "0x564d8e7ff538", - "kind": "DefaultStmt", - "range": { - "begin": { - "offset": 38023, - "line": 1253, - "col": 9, - "tokLen": 7 - }, - "end": { - "offset": 38099, - "line": 1254, - "col": 68, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff520", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 38044, - "col": 13, - "tokLen": 5 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ff508", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 38044, - "col": 13, - "tokLen": 5 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ff4e0", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 38050, - "col": 19, - "tokLen": 12 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7ff4c0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 38050, - "col": 19, - "tokLen": 12 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ff4b8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ff488", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 38050, - "col": 19, - "tokLen": 12 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7ff470", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38063, - "col": 32, - "tokLen": 36 - }, - "end": { - "offset": 38063, - "col": 32, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ff3f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 38063, - "col": 32, - "tokLen": 36 - }, - "end": { - "offset": 38063, - "col": 32, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char[35]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean. Expecting 0 or 1.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7ff6e8", - "kind": "DefaultStmt", - "range": { - "begin": { - "offset": 38122, - "line": 1257, - "col": 5, - "tokLen": 7 - }, - "end": { - "offset": 38183, - "line": 1258, - "col": 53, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff6d0", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 38139, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ff6b8", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 38139, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ff690", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 38145, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7ff670", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 38145, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ff668", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ff638", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 38145, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7ff620", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38158, - "col": 28, - "tokLen": 25 - }, - "end": { - "offset": 38158, - "col": 28, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ff5b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 38158, - "col": 28, - "tokLen": 25 - }, - "end": { - "offset": 38158, - "col": 28, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char[24]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean format.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} -{ - "id": "0x564d8e7ff890", - "kind": "FunctionDecl", - "loc": { - "offset": 38215, - "file": "ToString.cpp", - "line": 1262, - "col": 21, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 38195, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 38348, - "line": 1265, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3af830", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "long" - }, - "inner": [ - { - "id": "0x564d8c93dc10", - "kind": "BuiltinType", - "type": { - "qualType": "long" - } - } - ] - }, - { - "id": "0x564d8e7ff7c0", - "kind": "ParmVarDecl", - "loc": { - "offset": 38243, - "line": 1262, - "col": 49, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 38224, - "col": 30, - "tokLen": 5 - }, - "end": { - "offset": 38243, - "col": 49, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e800790", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 38246, - "col": 52, - "tokLen": 1 - }, - "end": { - "offset": 38348, - "line": 1265, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e800598", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 38252, - "line": 1263, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 38306, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ffa60", - "kind": "VarDecl", - "loc": { - "offset": 38256, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 38252, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 38304, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e800568", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38304, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e800508", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38292, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e8003e0", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38274, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e8003b0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38265, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7ffac8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38263, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ff7c0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e800410", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38270, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 38270, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ffb60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 38270, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 38270, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e800428", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e8004f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38279, - "file": "ToString.cpp", - "line": 1263, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 38292, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e8004c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38279, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 38292, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e800528", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 38299, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 38299, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e800548", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 38304, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 38304, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e800780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 38312, - "line": 1264, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 38345, - "col": 38, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e800718", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 38319, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 38345, - "col": 38, - "tokLen": 1 - } - }, - "type": { - "qualType": "long" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e800700", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38319, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 38324, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "long (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e800670", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38319, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 38324, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "long (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6c6798", - "kind": "FunctionDecl", - "name": "stol", - "type": { - "qualType": "long (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e800620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38329, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 38329, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ff7c0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e800750", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38332, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 38332, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e800640", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 38332, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 38332, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e800768", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38341, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 38341, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e800650", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38341, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 38341, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ffa60", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] -} diff --git a/slsDetectorSoftware/generator/autocomplete/fixed.json b/slsDetectorSoftware/generator/autocomplete/fixed.json deleted file mode 100644 index 12d7fa59f..000000000 --- a/slsDetectorSoftware/generator/autocomplete/fixed.json +++ /dev/null @@ -1,70939 +0,0 @@ -[ -{ - "id": "0x564d8e36fb48", - "kind": "FunctionTemplateDecl", - "loc": { - "offset": 9063, - "file": "../include/sls/ToString.h", - "line": 283, - "col": 3, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9039, - "line": 282, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9904, - "line": 305, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "inner": [ - { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "loc": { - "offset": 9058, - "line": 282, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9049, - "col": 11, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9058, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "T", - "tagUsed": "typename", - "depth": 0, - "index": 0 - }, - { - "id": "0x564d8e36faa0", - "kind": "FunctionDecl", - "loc": { - "offset": 9063, - "line": 283, - "col": 3, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9061, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9904, - "line": 305, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "type": { - "qualType": "T (const std::string &, const std::string &)" - }, - "inner": [ - { - "id": "0x564d8e36f8c8", - "kind": "ParmVarDecl", - "loc": { - "offset": 9091, - "line": 283, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9072, - "col": 12, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9091, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "t", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "loc": { - "offset": 9113, - "col": 53, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9094, - "col": 34, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9113, - "col": 53, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "unit", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e3a49e8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9119, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9904, - "line": 305, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36fd70", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9125, - "line": 284, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9139, - "col": 19, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "loc": { - "offset": 9132, - "col": 12, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9125, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9138, - "col": 18, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "tval", - "type": { - "qualType": "double" - }, - "init": "list", - "inner": [ - { - "id": "0x564d8e36fd10", - "kind": "InitListExpr", - "range": { - "begin": { - "offset": 9136, - "col": 16, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9138, - "col": 18, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e36fd50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "prvalue", - "castKind": "IntegralToFloating", - "inner": [ - { - "id": "0x564d8e36fc98", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9137, - "col": 17, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3702a8", - "kind": "CXXTryStmt", - "range": { - "begin": { - "offset": 9145, - "line": 285, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9295, - "line": 289, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36ff58", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9149, - "line": 285, - "col": 9, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9184, - "line": 287, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e36ff38", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 9159, - "line": 286, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9177, - "col": 27, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "opcode": "=", - "inner": [ - { - "id": "0x564d8e36fd88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9159, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9159, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - }, - { - "id": "0x564d8e36fee8", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9166, - "col": 16, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9177, - "col": 27, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e36fed0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9166, - "col": 16, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9171, - "col": 21, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double (*)(const string &, size_t *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e36fe38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9166, - "col": 16, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9171, - "col": 21, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double (const string &, size_t *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6ca7f8", - "kind": "FunctionDecl", - "name": "stod", - "type": { - "qualType": "double (const string &, size_t *)" - } - } - } - ] - }, - { - "id": "0x564d8e36fe18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9176, - "col": 26, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9176, - "col": 26, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f8c8", - "kind": "ParmVarDecl", - "name": "t", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e36ff18", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8d6ca728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 159105, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 4489, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 159105, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8d6ca708", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 159105, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 159105, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e370288", - "kind": "CXXCatchStmt", - "range": { - "begin": { - "offset": 9186, - "file": "../include/sls/ToString.h", - "line": 287, - "col": 7, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9295, - "line": 289, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e370028", - "kind": "VarDecl", - "loc": { - "offset": 9222, - "line": 287, - "col": 43, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9193, - "col": 14, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9222, - "col": 43, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "e", - "type": { - "qualType": "const std::invalid_argument &" - } - }, - { - "id": "0x564d8e370270", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9225, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9295, - "line": 289, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e370258", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 9235, - "line": 288, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e370240", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 9235, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e370218", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9241, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e3701f8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 9241, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e3701f0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e3701c0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9241, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9288, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e370178", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e370100", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9254, - "col": 28, - "tokLen": 34, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[33]" - }, - "valueCategory": "lvalue", - "value": "\"Could not convert string to time\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e370380", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9302, - "line": 291, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9329, - "col": 32, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3702d8", - "kind": "UsingDecl", - "loc": { - "offset": 9321, - "col": 24, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9302, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9321, - "col": 24, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "std::chrono::duration" - } - ] - }, - { - "id": "0x564d8e370450", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9335, - "line": 292, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9367, - "col": 37, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3703a8", - "kind": "UsingDecl", - "loc": { - "offset": 9354, - "col": 24, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9335, - "col": 5, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9354, - "col": 24, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "std::chrono::duration_cast" - } - ] - }, - { - "id": "0x564d8e3a49b8", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9373, - "line": 293, - "col": 5, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e3717c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9377, - "line": 293, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e3717a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e371788", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9382, - "col": 14, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e370468", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9377, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9377, - "col": 9, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e371770", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e370488", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9385, - "col": 17, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"ns\"" - } - ] - } - ] - }, - { - "id": "0x564d8e384d38", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9391, - "col": 23, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9465, - "line": 295, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e384d28", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9401, - "line": 294, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9458, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e384d00", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9408, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9458, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e371820", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9408, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9423, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e384cd8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9425, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9457, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e384980", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e384ca8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9425, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9457, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e384ad0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e371b00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9453, - "col": 61, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4988", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9472, - "line": 295, - "col": 12, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e3860b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9476, - "line": 295, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e386098", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e386078", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9481, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e384d50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9476, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9476, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e386060", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e384d70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9484, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"us\"" - } - ] - } - ] - }, - { - "id": "0x564d8e38f5c8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9490, - "col": 30, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9565, - "line": 297, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e38f5b8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9500, - "line": 296, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9558, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e38f590", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9507, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9558, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3860f8", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9507, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9522, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e38f568", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9524, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9557, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e38f210", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e38f538", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9524, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9557, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e38f360", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3863c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9553, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4958", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9572, - "line": 297, - "col": 12, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e390940", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9576, - "line": 297, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e390928", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e390908", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9581, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e38f5e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9576, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9576, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e3908f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e38f600", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9584, - "col": 24, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"ms\"" - } - ] - } - ] - }, - { - "id": "0x564d8e399e38", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9590, - "col": 30, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9665, - "line": 299, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e399e28", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9600, - "line": 298, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9658, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e399e00", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9607, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9658, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e390988", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9607, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9622, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e399dd8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9624, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9657, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e399a80", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e399da8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9624, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9657, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::chrono::duration>", - "qualType": "duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e399bd0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e390c50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9653, - "col": 62, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4928", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 9672, - "line": 299, - "col": 12, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "hasElse": true, - "inner": [ - { - "id": "0x564d8e39b290", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 9676, - "line": 299, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9702, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e39b1b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 9676, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e39b198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e39b178", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9681, - "col": 21, - "tokLen": 2, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e399e50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9676, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9676, - "col": 16, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e39b160", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e399e70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9684, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"s\"" - } - ] - } - ] - }, - { - "id": "0x564d8e39b238", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9702, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e39b208", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9696, - "col": 36, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "empty", - "isArrow": false, - "referencedMemberDecl": "0x564d8d69dff8", - "inner": [ - { - "id": "0x564d8e39b1e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9691, - "col": 31, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36f988", - "kind": "ParmVarDecl", - "name": "unit", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4758", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9705, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9781, - "line": 301, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a4748", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 9715, - "line": 300, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9774, - "col": 68, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a4720", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 9722, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9774, - "col": 68, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e39b2c0", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 9722, - "col": 16, - "tokLen": 13, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9737, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "duration_cast", - "lookups": [ - { - "id": "0x564d8e370400", - "kind": "UsingShadowDecl", - "name": "duration_cast" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e36f820", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e36f7d0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e3a46f8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9739, - "col": 33, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9773, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::chrono::duration" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8e3a43a0", - "kind": "CXXConstructorDecl", - "name": "duration", - "type": { - "qualType": "void (const double &)" - } - }, - "inner": [ - { - "id": "0x564d8e3a46c8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9739, - "col": 33, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9773, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::chrono::duration" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const double &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e3a44f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const double" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e39b570", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9769, - "col": 63, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "double" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e36fc30", - "kind": "VarDecl", - "name": "tval", - "type": { - "qualType": "double" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a4910", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9788, - "line": 301, - "col": 12, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9902, - "line": 304, - "col": 5, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a48f8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 9798, - "line": 302, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e3a48e0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 9798, - "line": 302, - "col": 9, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3a48b8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 9804, - "line": 302, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e3a4898", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 9804, - "line": 302, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e3a4890", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e3a4860", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9804, - "line": 302, - "col": 15, - "tokLen": 12, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9895, - "line": 303, - "col": 78, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e3a4848", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e3a47b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9830, - "col": 13, - "tokLen": 65, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const char[64]" - }, - "valueCategory": "lvalue", - "value": "\"Invalid unit in conversion from string to std::chrono::duration\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e3a4cc8", - "kind": "FunctionTemplateDecl", - "loc": { - "offset": 9931, - "file": "../include/sls/ToString.h", - "line": 307, - "col": 25, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9907, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10056, - "line": 311, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "inner": [ - { - "id": "0x564d8e3a4a20", - "kind": "TemplateTypeParmDecl", - "loc": { - "offset": 9926, - "line": 307, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9917, - "col": 11, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9926, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "T", - "tagUsed": "typename", - "depth": 0, - "index": 0 - }, - { - "id": "0x564d8e3a4c20", - "kind": "FunctionDecl", - "loc": { - "offset": 9931, - "col": 25, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9929, - "col": 23, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10056, - "line": 311, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "type": { - "qualType": "T (const std::string &)" - }, - "inner": [ - { - "id": "0x564d8e3a4b18", - "kind": "ParmVarDecl", - "loc": { - "offset": 9959, - "line": 307, - "col": 53, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9940, - "col": 34, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9959, - "col": 53, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "t", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e3a5bd8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 9962, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10056, - "line": 311, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a57b0", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9968, - "line": 308, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9986, - "col": 23, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a4de8", - "kind": "VarDecl", - "loc": { - "offset": 9980, - "col": 17, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9968, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9985, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "tmp", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "init": "list", - "inner": [ - { - "id": "0x564d8e3a5780", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 9980, - "col": 17, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9985, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const basic_string &)" - }, - "list": true, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e3a4e50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 9984, - "col": 21, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 9984, - "col": 21, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a4b18", - "kind": "ParmVarDecl", - "name": "t", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a5a98", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 9992, - "line": 309, - "col": 5, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10019, - "col": 32, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a57e0", - "kind": "VarDecl", - "loc": { - "offset": 9997, - "col": 10, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 9992, - "col": 5, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "unit", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3a5a80", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e3a5978", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e3a5970", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e3a5948", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10018, - "col": 31, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3a5930", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::string (*)(std::string &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3a58b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10004, - "col": 17, - "tokLen": 10, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "std::string (std::string &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8ddb34e0", - "kind": "FunctionDecl", - "name": "RemoveUnit", - "type": { - "qualType": "std::string (std::string &)" - } - } - } - ] - }, - { - "id": "0x564d8e3a5890", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10015, - "col": 28, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10015, - "col": 28, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a4de8", - "kind": "VarDecl", - "name": "tmp", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3a5bc8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 10025, - "line": 310, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10053, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3a5b98", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 10032, - "col": 12, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10053, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3a5ad8", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 10032, - "col": 12, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10042, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "StringTo", - "lookups": [ - { - "id": "0x564d8e3a4cc8", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - }, - { - "id": "0x564d8e36fb48", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e3a4a70", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e3a4a20", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e3a5b58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10044, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10044, - "col": 24, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a4de8", - "kind": "VarDecl", - "name": "tmp", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - }, - { - "id": "0x564d8e3a5b78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 10049, - "col": 29, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10049, - "col": 29, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3a57e0", - "kind": "VarDecl", - "name": "unit", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e6e5410", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::detectorType (const std::string &)" - } - }, - { - "id": "0x564d8e6effb0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::detectorSettings (const std::string &)" - } - }, - { - "id": "0x564d8e709dc0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::speedLevel (const std::string &)" - } - }, - { - "id": "0x564d8e714930", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::timingMode (const std::string &)" - } - }, - { - "id": "0x564d8e71b800", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::frameDiscardPolicy (const std::string &)" - } - }, - { - "id": "0x564d8e71fea0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::fileFormat (const std::string &)" - } - }, - { - "id": "0x564d8e7230b0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::externalSignalFlag (const std::string &)" - } - }, - { - "id": "0x564d8e728b60", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::readoutMode (const std::string &)" - } - }, - { - "id": "0x564d8e72fa60", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::dacIndex (const std::string &)" - } - }, - { - "id": "0x564d8e7b5a50", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::powerIndex (const std::string &)" - } - }, - { - "id": "0x564d8e7bdd60", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::burstMode (const std::string &)" - } - }, - { - "id": "0x564d8e7c37f0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::timingSourceType (const std::string &)" - } - }, - { - "id": "0x564d8e7c6a40", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::M3_GainCaps (const std::string &)" - } - }, - { - "id": "0x564d8e7ced30", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::portPosition (const std::string &)" - } - }, - { - "id": "0x564d8e7d47b0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::streamingInterface (const std::string &)" - } - }, - { - "id": "0x564d8e7da5c0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::vetoAlgorithm (const std::string &)" - } - }, - { - "id": "0x564d8e7dd7f0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::gainMode (const std::string &)" - } - }, - { - "id": "0x564d8e7e5ae0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::polarity (const std::string &)" - } - }, - { - "id": "0x564d8e7e8cf0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::timingInfoDecoder (const std::string &)" - } - }, - { - "id": "0x564d8e7ebf40", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "defs::collectionMode (const std::string &)" - } - }, - { - "id": "0x564d8e3acd20", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "RegisterAddress (const std::string &)" - } - }, - { - "id": "0x564d8e3ad230", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "RegisterValue (const std::string &)" - } - }, - { - "id": "0x564d8e7ef130", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint8_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f42a0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint16_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f6320", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint32_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f7390", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "uint64_t (const std::string &)" - } - }, - { - "id": "0x564d8e7f8408", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "int (const std::string &)" - } - }, - { - "id": "0x564d8e7f9410", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "bool (const std::string &)" - } - }, - { - "id": "0x564d8e7ff890", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "int64_t (const std::string &)" - } - } - ] -}, -{ - "id": "0x564d8e3a5dd0", - "kind": "FunctionDecl", - "loc": { - "offset": 10090, - "file": "../include/sls/ToString.h", - "line": 313, - "col": 32, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10059, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10119, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a6040", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12detectorTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "inner": [ - { - "id": "0x564d8dc74900", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "decl": { - "id": "0x564d8dc74860", - "kind": "EnumDecl", - "name": "detectorType" - } - } - ] - }, - { - "id": "0x564d8e3a5cb0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10118, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10099, - "col": 41, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10118, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a6360", - "kind": "FunctionDecl", - "loc": { - "offset": 10157, - "file": "../include/sls/ToString.h", - "line": 314, - "col": 36, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10122, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10186, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a65d0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16detectorSettingsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorSettings (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "inner": [ - { - "id": "0x564d8dd58ab0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "decl": { - "id": "0x564d8dd58a08", - "kind": "EnumDecl", - "name": "detectorSettings" - } - } - ] - }, - { - "id": "0x564d8e3a6240", - "kind": "ParmVarDecl", - "loc": { - "offset": 10185, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10166, - "col": 45, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10185, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a68f0", - "kind": "FunctionDecl", - "loc": { - "offset": 10218, - "file": "../include/sls/ToString.h", - "line": 315, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10189, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10247, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a6b60", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10speedLevelEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::speedLevel (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "inner": [ - { - "id": "0x564d8dd59860", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "decl": { - "id": "0x564d8dd597b8", - "kind": "EnumDecl", - "name": "speedLevel" - } - } - ] - }, - { - "id": "0x564d8e3a67d0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10246, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10227, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10246, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a6e80", - "kind": "FunctionDecl", - "loc": { - "offset": 10279, - "file": "../include/sls/ToString.h", - "line": 316, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10250, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10308, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a70f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10timingModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "inner": [ - { - "id": "0x564d8dd56080", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "decl": { - "id": "0x564d8dd55fd8", - "kind": "EnumDecl", - "name": "timingMode" - } - } - ] - }, - { - "id": "0x564d8e3a6d60", - "kind": "ParmVarDecl", - "loc": { - "offset": 10307, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10288, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10307, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a7410", - "kind": "FunctionDecl", - "loc": { - "offset": 10348, - "file": "../include/sls/ToString.h", - "line": 317, - "col": 38, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10311, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10377, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a7680", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18frameDiscardPolicyEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::frameDiscardPolicy (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "inner": [ - { - "id": "0x564d8dd540b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "decl": { - "id": "0x564d8dd54008", - "kind": "EnumDecl", - "name": "frameDiscardPolicy" - } - } - ] - }, - { - "id": "0x564d8e3a72f0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10376, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10357, - "col": 47, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10376, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a79a0", - "kind": "FunctionDecl", - "loc": { - "offset": 10409, - "file": "../include/sls/ToString.h", - "line": 318, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10380, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10438, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a7c10", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10fileFormatEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::fileFormat (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "inner": [ - { - "id": "0x564d8dd542d0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "decl": { - "id": "0x564d8dd54230", - "kind": "EnumDecl", - "name": "fileFormat" - } - } - ] - }, - { - "id": "0x564d8e3a7880", - "kind": "ParmVarDecl", - "loc": { - "offset": 10437, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10418, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10437, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a7f30", - "kind": "FunctionDecl", - "loc": { - "offset": 10478, - "file": "../include/sls/ToString.h", - "line": 319, - "col": 38, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10441, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10507, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a81a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18externalSignalFlagEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::externalSignalFlag (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "inner": [ - { - "id": "0x564d8dd55e30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "decl": { - "id": "0x564d8dd55d88", - "kind": "EnumDecl", - "name": "externalSignalFlag" - } - } - ] - }, - { - "id": "0x564d8e3a7e10", - "kind": "ParmVarDecl", - "loc": { - "offset": 10506, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10487, - "col": 47, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10506, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a84c0", - "kind": "FunctionDecl", - "loc": { - "offset": 10540, - "file": "../include/sls/ToString.h", - "line": 320, - "col": 31, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10510, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10569, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a8730", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11readoutModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::readoutMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "inner": [ - { - "id": "0x564d8dd595b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "decl": { - "id": "0x564d8dd59508", - "kind": "EnumDecl", - "name": "readoutMode" - } - } - ] - }, - { - "id": "0x564d8e3a83a0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10568, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10549, - "col": 40, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10568, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a8a50", - "kind": "FunctionDecl", - "loc": { - "offset": 10599, - "file": "../include/sls/ToString.h", - "line": 321, - "col": 28, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10572, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10628, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a8cc0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8dacIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::dacIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "inner": [ - { - "id": "0x564d8dd56380", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "decl": { - "id": "0x564d8dd562d8", - "kind": "EnumDecl", - "name": "dacIndex" - } - } - ] - }, - { - "id": "0x564d8e3a8930", - "kind": "ParmVarDecl", - "loc": { - "offset": 10627, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10608, - "col": 37, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10627, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a8fe0", - "kind": "FunctionDecl", - "loc": { - "offset": 10660, - "file": "../include/sls/ToString.h", - "line": 322, - "col": 30, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10631, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10689, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a9250", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10powerIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::powerIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "inner": [ - { - "id": "0x564d8dd585f0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "decl": { - "id": "0x564d8dd58550", - "kind": "EnumDecl", - "name": "powerIndex" - } - } - ] - }, - { - "id": "0x564d8e3a8ec0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10688, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10669, - "col": 39, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10688, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a9570", - "kind": "FunctionDecl", - "loc": { - "offset": 10720, - "file": "../include/sls/ToString.h", - "line": 323, - "col": 29, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10692, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10749, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a9840", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs9burstModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::burstMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "inner": [ - { - "id": "0x564d8dd59b10", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "decl": { - "id": "0x564d8dd59a68", - "kind": "EnumDecl", - "name": "burstMode" - } - } - ] - }, - { - "id": "0x564d8e3a9450", - "kind": "ParmVarDecl", - "loc": { - "offset": 10748, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10729, - "col": 38, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10748, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3a9b60", - "kind": "FunctionDecl", - "loc": { - "offset": 10787, - "file": "../include/sls/ToString.h", - "line": 324, - "col": 36, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10752, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10816, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3a9dd0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16timingSourceTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingSourceType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "inner": [ - { - "id": "0x564d8dd59dc0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "decl": { - "id": "0x564d8dd59d18", - "kind": "EnumDecl", - "name": "timingSourceType" - } - } - ] - }, - { - "id": "0x564d8e3a9a40", - "kind": "ParmVarDecl", - "loc": { - "offset": 10815, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10796, - "col": 45, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10815, - "col": 64, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3aa0f0", - "kind": "FunctionDecl", - "loc": { - "offset": 10849, - "file": "../include/sls/ToString.h", - "line": 325, - "col": 31, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10819, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10878, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aa360", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11M3_GainCapsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::M3_GainCaps (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "inner": [ - { - "id": "0x564d8dd59f30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "decl": { - "id": "0x564d8dd59e90", - "kind": "EnumDecl", - "name": "M3_GainCaps" - } - } - ] - }, - { - "id": "0x564d8e3a9fd0", - "kind": "ParmVarDecl", - "loc": { - "offset": 10877, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10858, - "col": 40, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10877, - "col": 59, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3aa680", - "kind": "FunctionDecl", - "loc": { - "offset": 10912, - "file": "../include/sls/ToString.h", - "line": 326, - "col": 32, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10881, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10941, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aa8f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12portPositionEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::portPosition (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "inner": [ - { - "id": "0x564d8dd5a590", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "decl": { - "id": "0x564d8dd5a4f0", - "kind": "EnumDecl", - "name": "portPosition" - } - } - ] - }, - { - "id": "0x564d8e3aa560", - "kind": "ParmVarDecl", - "loc": { - "offset": 10940, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10921, - "col": 41, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 10940, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3aac10", - "kind": "FunctionDecl", - "loc": { - "offset": 10981, - "file": "../include/sls/ToString.h", - "line": 327, - "col": 38, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10944, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11010, - "col": 67, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aae80", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18streamingInterfaceEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::streamingInterface (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "inner": [ - { - "id": "0x564d8dd5a950", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "decl": { - "id": "0x564d8dd5a8b0", - "kind": "EnumDecl", - "name": "streamingInterface" - } - } - ] - }, - { - "id": "0x564d8e3aaaf0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11009, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 10990, - "col": 47, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11009, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ab1a0", - "kind": "FunctionDecl", - "loc": { - "offset": 11045, - "file": "../include/sls/ToString.h", - "line": 328, - "col": 33, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11013, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11074, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ab410", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs13vetoAlgorithmEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::vetoAlgorithm (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "inner": [ - { - "id": "0x564d8dd5ad30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "decl": { - "id": "0x564d8dd5ac90", - "kind": "EnumDecl", - "name": "vetoAlgorithm" - } - } - ] - }, - { - "id": "0x564d8e3ab080", - "kind": "ParmVarDecl", - "loc": { - "offset": 11073, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11054, - "col": 42, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11073, - "col": 61, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ab730", - "kind": "FunctionDecl", - "loc": { - "offset": 11104, - "file": "../include/sls/ToString.h", - "line": 329, - "col": 28, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11077, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11133, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ab9a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8gainModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::gainMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "inner": [ - { - "id": "0x564d8dd5aea0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "decl": { - "id": "0x564d8dd5ae00", - "kind": "EnumDecl", - "name": "gainMode" - } - } - ] - }, - { - "id": "0x564d8e3ab610", - "kind": "ParmVarDecl", - "loc": { - "offset": 11132, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11113, - "col": 37, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11132, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3abcc0", - "kind": "FunctionDecl", - "loc": { - "offset": 11163, - "file": "../include/sls/ToString.h", - "line": 330, - "col": 28, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11136, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11192, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3abf30", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8polarityEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::polarity (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "inner": [ - { - "id": "0x564d8dd5b170", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "decl": { - "id": "0x564d8dd5b0d0", - "kind": "EnumDecl", - "name": "polarity" - } - } - ] - }, - { - "id": "0x564d8e3abba0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11191, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11172, - "col": 37, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11191, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ac250", - "kind": "FunctionDecl", - "loc": { - "offset": 11231, - "file": "../include/sls/ToString.h", - "line": 331, - "col": 37, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11195, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11260, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ac4c0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs17timingInfoDecoderEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingInfoDecoder (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "inner": [ - { - "id": "0x564d8dd5b2e0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "decl": { - "id": "0x564d8dd5b240", - "kind": "EnumDecl", - "name": "timingInfoDecoder" - } - } - ] - }, - { - "id": "0x564d8e3ac130", - "kind": "ParmVarDecl", - "loc": { - "offset": 11259, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11240, - "col": 46, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11259, - "col": 65, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ac7e0", - "kind": "FunctionDecl", - "loc": { - "offset": 11296, - "file": "../include/sls/ToString.h", - "line": 332, - "col": 34, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11263, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11325, - "col": 63, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aca50", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs14collectionModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::collectionMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "inner": [ - { - "id": "0x564d8dd5b450", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "decl": { - "id": "0x564d8dd5b3b0", - "kind": "EnumDecl", - "name": "collectionMode" - } - } - ] - }, - { - "id": "0x564d8e3ac6c0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11324, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11305, - "col": 43, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11324, - "col": 62, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3acd20", - "kind": "FunctionDecl", - "loc": { - "offset": 11356, - "file": "../include/sls/ToString.h", - "line": 333, - "col": 29, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11328, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11385, - "col": 58, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3acf60", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToINS_15RegisterAddressEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "RegisterAddress (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "sls::RegisterAddress" - }, - "inner": [ - { - "id": "0x564d8d8f3f60", - "kind": "RecordType", - "type": { - "qualType": "sls::RegisterAddress" - }, - "decl": { - "id": "0x564d8d8f3ed0", - "kind": "CXXRecordDecl", - "name": "RegisterAddress" - } - } - ] - }, - { - "id": "0x564d8e3acc10", - "kind": "ParmVarDecl", - "loc": { - "offset": 11384, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11365, - "col": 38, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11384, - "col": 57, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ad230", - "kind": "FunctionDecl", - "loc": { - "offset": 11414, - "file": "../include/sls/ToString.h", - "line": 334, - "col": 27, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11388, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11443, - "col": 56, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ad470", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToINS_13RegisterValueEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "RegisterValue (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "sls::RegisterValue" - }, - "inner": [ - { - "id": "0x564d8d8f7650", - "kind": "RecordType", - "type": { - "qualType": "sls::RegisterValue" - }, - "decl": { - "id": "0x564d8d8f75c0", - "kind": "CXXRecordDecl", - "name": "RegisterValue" - } - } - ] - }, - { - "id": "0x564d8e3ad120", - "kind": "ParmVarDecl", - "loc": { - "offset": 11442, - "col": 55, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11423, - "col": 36, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11442, - "col": 55, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ad740", - "kind": "FunctionDecl", - "loc": { - "offset": 11467, - "file": "../include/sls/ToString.h", - "line": 336, - "col": 21, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11447, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11496, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ad980", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIhEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint8_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned char" - }, - "inner": [ - { - "id": "0x564d8c93dc50", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned char" - } - } - ] - }, - { - "id": "0x564d8e3ad630", - "kind": "ParmVarDecl", - "loc": { - "offset": 11495, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11476, - "col": 30, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11495, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3adc50", - "kind": "FunctionDecl", - "loc": { - "offset": 11520, - "file": "../include/sls/ToString.h", - "line": 337, - "col": 22, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11499, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11549, - "col": 51, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ade90", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToItEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint16_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned short" - }, - "inner": [ - { - "id": "0x564d8c93dc70", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned short" - } - } - ] - }, - { - "id": "0x564d8e3adb40", - "kind": "ParmVarDecl", - "loc": { - "offset": 11548, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11529, - "col": 31, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11548, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ae160", - "kind": "FunctionDecl", - "loc": { - "offset": 11573, - "file": "../include/sls/ToString.h", - "line": 338, - "col": 22, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11552, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11602, - "col": 51, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ae3a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIjEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint32_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned int" - }, - "inner": [ - { - "id": "0x564d8c93dc90", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned int" - } - } - ] - }, - { - "id": "0x564d8e3ae050", - "kind": "ParmVarDecl", - "loc": { - "offset": 11601, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11582, - "col": 31, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11601, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3ae630", - "kind": "FunctionDecl", - "loc": { - "offset": 11626, - "file": "../include/sls/ToString.h", - "line": 339, - "col": 22, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11605, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11655, - "col": 51, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3ae870", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToImEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned long" - }, - "inner": [ - { - "id": "0x564d8c93dcb0", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned long" - } - } - ] - }, - { - "id": "0x564d8e3ae560", - "kind": "ParmVarDecl", - "loc": { - "offset": 11654, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11635, - "col": 31, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11654, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3aeb48", - "kind": "FunctionDecl", - "loc": { - "offset": 11674, - "file": "../include/sls/ToString.h", - "line": 340, - "col": 17, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11658, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11703, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3aed90", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIiEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "int" - }, - "inner": [ - { - "id": "0x564d8c93dbf0", - "kind": "BuiltinType", - "type": { - "qualType": "int" - } - } - ] - }, - { - "id": "0x564d8e3aea30", - "kind": "ParmVarDecl", - "loc": { - "offset": 11702, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11683, - "col": 26, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11702, - "col": 45, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3af020", - "kind": "FunctionDecl", - "loc": { - "offset": 11723, - "file": "../include/sls/ToString.h", - "line": 341, - "col": 18, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11706, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11752, - "col": 47, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3af260", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIbEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "bool (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "bool" - }, - "inner": [ - { - "id": "0x564d8c93db70", - "kind": "BuiltinType", - "type": { - "qualType": "bool" - } - } - ] - }, - { - "id": "0x564d8e3aef50", - "kind": "ParmVarDecl", - "loc": { - "offset": 11751, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11732, - "col": 27, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11751, - "col": 46, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3af5f0", - "kind": "FunctionDecl", - "loc": { - "offset": 11760, - "file": "../include/sls/ToString.h", - "line": 342, - "col": 6, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11755, - "col": 1, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11814, - "col": 60, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isUsed": true, - "name": "StringTo", - "mangledName": "_ZN3sls8StringToERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN15slsDetectorDefs10boolFormatE", - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - }, - "inner": [ - { - "id": "0x564d8e3af408", - "kind": "ParmVarDecl", - "loc": { - "offset": 11788, - "col": 34, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11769, - "col": 15, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11788, - "col": 34, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e3af4d0", - "kind": "ParmVarDecl", - "loc": { - "offset": 11808, - "col": 54, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11791, - "col": 37, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11808, - "col": 54, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "format", - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - } - } - ] -}, -{ - "id": "0x564d8e3af830", - "kind": "FunctionDecl", - "loc": { - "offset": 11837, - "file": "../include/sls/ToString.h", - "line": 343, - "col": 21, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11817, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11866, - "col": 50, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "previousDecl": "0x564d8e3afa70", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "long" - }, - "inner": [ - { - "id": "0x564d8c93dc10", - "kind": "BuiltinType", - "type": { - "qualType": "long" - } - } - ] - }, - { - "id": "0x564d8e3af728", - "kind": "ParmVarDecl", - "loc": { - "offset": 11865, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 11846, - "col": 30, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 11865, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - ] -}, -{ - "id": "0x564d8e3b0a28", - "kind": "FunctionTemplateDecl", - "loc": { - "offset": 12103, - "file": "../include/sls/ToString.h", - "line": 353, - "col": 16, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12066, - "line": 352, - "col": 1, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12313, - "line": 359, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "inner": [ - { - "id": "0x564d8e3b03b0", - "kind": "TemplateTypeParmDecl", - "loc": { - "offset": 12085, - "line": 352, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12076, - "col": 11, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12085, - "col": 20, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "T", - "tagUsed": "typename", - "depth": 0, - "index": 0 - }, - { - "id": "0x564d8e3b0980", - "kind": "FunctionDecl", - "loc": { - "offset": 12103, - "line": 353, - "col": 16, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12088, - "col": 1, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12313, - "line": 359, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "name": "StringTo", - "type": { - "qualType": "std::vector (const std::vector &)" - }, - "inner": [ - { - "id": "0x564d8e3b0858", - "kind": "ParmVarDecl", - "loc": { - "offset": 12144, - "line": 353, - "col": 57, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12112, - "col": 25, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12144, - "col": 57, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "strings", - "type": { - "qualType": "const std::vector &" - } - }, - { - "id": "0x564d8e3e1eb0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 12153, - "col": 66, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12313, - "line": 359, - "col": 1, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3b0d20", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12159, - "line": 354, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12180, - "col": 26, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "loc": { - "offset": 12174, - "col": 20, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12159, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12174, - "col": 20, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "nrvo": true - } - ] - }, - { - "id": "0x564d8e3da3e0", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 12186, - "line": 355, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12215, - "col": 34, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3b0d58", - "kind": "CXXDependentScopeMemberExpr", - "range": { - "begin": { - "offset": 12186, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12193, - "col": 12, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "isArrow": false, - "member": "reserve", - "inner": [ - { - "id": "0x564d8e3b0d38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12186, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12186, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - } - } - } - ] - }, - { - "id": "0x564d8e3d9eb8", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12214, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d0a5778" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3d9e88", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12209, - "col": 28, - "tokLen": 4, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "size", - "isArrow": false, - "referencedMemberDecl": "0x564d8e3ce890", - "inner": [ - { - "id": "0x564d8e3b0da0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12201, - "col": 20, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0858", - "kind": "ParmVarDecl", - "name": "strings", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1c88", - "kind": "CXXForRangeStmt", - "range": { - "begin": { - "offset": 12222, - "line": 356, - "col": 5, - "tokLen": 3, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12291, - "line": 357, - "col": 40, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - {}, - { - "id": "0x564d8e3da718", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12243, - "line": 356, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da520", - "kind": "VarDecl", - "loc": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isImplicit": true, - "isReferenced": true, - "name": "__range2", - "type": { - "qualType": "const std::vector &" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3da408", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12243, - "col": 26, - "tokLen": 7, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0858", - "kind": "ParmVarDecl", - "name": "strings", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e3de940", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "loc": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isImplicit": true, - "isReferenced": true, - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3da900", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3da8d0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "begin", - "isArrow": false, - "referencedMemberDecl": "0x564d8e3cd938", - "inner": [ - { - "id": "0x564d8e3da730", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da520", - "kind": "VarDecl", - "name": "__range2", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3de958", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da808", - "kind": "VarDecl", - "loc": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isImplicit": true, - "isReferenced": true, - "name": "__end2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3de860", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3de830", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "end", - "isArrow": false, - "referencedMemberDecl": "0x564d8e3cdbc8", - "inner": [ - { - "id": "0x564d8e3da750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::vector>", - "qualType": "const std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da520", - "kind": "VarDecl", - "name": "__range2", - "type": { - "qualType": "const std::vector &" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1758", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e3e1740", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (*)(const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &, const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &) noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3e1390", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "bool (const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &, const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &) noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3df528", - "kind": "FunctionDecl", - "name": "operator!=", - "type": { - "qualType": "bool (const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &, const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>> &) noexcept" - } - } - } - ] - }, - { - "id": "0x564d8e3e1360", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const __gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3de970", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - }, - { - "id": "0x564d8e3e1378", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const __gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const __normal_iterator, allocator> *, vector, allocator>, allocator, allocator>>>>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3de990", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da808", - "kind": "VarDecl", - "name": "__end2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e3e18f8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "__normal_iterator *, vector>>" - }, - "valueCategory": "lvalue", - "inner": [ - { - "id": "0x564d8e3e18e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "__normal_iterator *, vector>> &(*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3e17b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "__normal_iterator *, vector>> &() noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3dd280", - "kind": "CXXMethodDecl", - "name": "operator++", - "type": { - "qualType": "__normal_iterator *, vector>> &() noexcept" - } - } - } - ] - }, - { - "id": "0x564d8e3e1790", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - }, - { - "id": "0x564d8e3da4e8", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 12227, - "col": 10, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12250, - "col": 33, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3da480", - "kind": "VarDecl", - "loc": { - "offset": 12239, - "col": 22, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "range": { - "begin": { - "offset": 12227, - "col": 10, - "tokLen": 5, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "isReferenced": true, - "name": "s", - "type": { - "qualType": "std::basic_string const &" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e3e1ac8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const std::basic_string" - }, - "valueCategory": "lvalue", - "inner": [ - { - "id": "0x564d8e3e1ab0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "reference (*)() const noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e3e1998", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "reference () const noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3dce18", - "kind": "CXXMethodDecl", - "name": "operator*", - "type": { - "qualType": "reference () const noexcept" - } - } - } - ] - }, - { - "id": "0x564d8e3e1980", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "const __gnu_cxx::__normal_iterator *, std::vector>>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e3e1960", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12241, - "col": 24, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da788", - "kind": "VarDecl", - "name": "__begin2", - "type": { - "desugaredQualType": "__gnu_cxx::__normal_iterator *, std::vector>>", - "qualType": "const_iterator", - "typeAliasDeclId": "0x564d8e3c3ed8" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1e50", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 12260, - "line": 357, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12291, - "col": 40, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3e1d08", - "kind": "CXXDependentScopeMemberExpr", - "range": { - "begin": { - "offset": 12260, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12267, - "col": 16, - "tokLen": 9, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "isArrow": false, - "member": "push_back", - "inner": [ - { - "id": "0x564d8e3e1ce8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12260, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12260, - "col": 9, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - } - } - } - ] - }, - { - "id": "0x564d8e3e1e28", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 12277, - "col": 26, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12290, - "col": 39, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e3e1d80", - "kind": "UnresolvedLookupExpr", - "range": { - "begin": { - "offset": 12277, - "col": 26, - "tokLen": 8, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12287, - "col": 36, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "lvalue", - "usesADL": true, - "name": "StringTo", - "lookups": [ - { - "id": "0x564d8e3b0a28", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - }, - { - "id": "0x564d8e36fb48", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - }, - { - "id": "0x564d8e3a4cc8", - "kind": "FunctionTemplateDecl", - "name": "StringTo" - } - ], - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "T" - }, - "inner": [ - { - "id": "0x564d8e3b0400", - "kind": "TemplateTypeParmType", - "type": { - "qualType": "T" - }, - "isDependent": true, - "isInstantiationDependent": true, - "depth": 0, - "index": 0, - "decl": { - "id": "0x564d8e3b03b0", - "kind": "TemplateTypeParmDecl", - "name": "T" - } - } - ] - } - ] - }, - { - "id": "0x564d8e3e1e08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12289, - "col": 38, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12289, - "col": 38, - "tokLen": 1, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "std::basic_string const" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3da480", - "kind": "VarDecl", - "name": "s", - "type": { - "qualType": "std::basic_string const &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e3e1e98", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 12298, - "line": 358, - "col": 5, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12305, - "col": 12, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "inner": [ - { - "id": "0x564d8e3e1e78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 12305, - "col": 12, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - }, - "end": { - "offset": 12305, - "col": 12, - "tokLen": 6, - "includedFrom": { - "file": "ToString.cpp" - } - } - }, - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3b0cb8", - "kind": "VarDecl", - "name": "result", - "type": { - "desugaredQualType": "vector", - "qualType": "std::vector" - } - } - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e6e5410", - "kind": "FunctionDecl", - "loc": { - "offset": 22683, - "file": "ToString.cpp", - "line": 742, - "col": 32, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 22652, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 23242, - "line": 760, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a5dd0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12detectorTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "inner": [ - { - "id": "0x564d8dc74900", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "decl": { - "id": "0x564d8dc74860", - "kind": "EnumDecl", - "name": "detectorType" - } - } - ] - }, - { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "loc": { - "offset": 22711, - "line": 742, - "col": 60, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 22692, - "col": 41, - "tokLen": 5 - }, - "end": { - "offset": 22711, - "col": 60, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e6efdd0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 22714, - "col": 63, - "tokLen": 1 - }, - "end": { - "offset": 23242, - "line": 760, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e6e6a00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22720, - "line": 743, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22759, - "line": 744, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e6e6950", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22724, - "line": 743, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22729, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6e6938", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22726, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22726, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e6918", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22726, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22726, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e55f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22724, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22724, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6e6900", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22729, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 22729, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e5618", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22729, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 22729, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"Eiger\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6e69f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22746, - "line": 744, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22759, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e6e69c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22753, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22759, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74978", - "kind": "EnumConstantDecl", - "name": "EIGER", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6e7e30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22770, - "line": 745, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22812, - "line": 746, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e7d80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22774, - "line": 745, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22779, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6e7d68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e7d48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e6a20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22774, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22774, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6e7d30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22779, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22779, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e6a40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22779, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22779, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"Gotthard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6e7e20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22799, - "line": 746, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22812, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e7df0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22806, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22812, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc749f8", - "kind": "EnumConstantDecl", - "name": "GOTTHARD", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6e9260", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22826, - "line": 747, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22868, - "line": 748, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e91b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22830, - "line": 747, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22835, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6e9198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22832, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22832, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e9178", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22832, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22832, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e7e50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22830, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22830, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6e9160", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22835, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22835, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e7e70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22835, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 22835, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"Jungfrau\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6e9250", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22855, - "line": 748, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22868, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6e9220", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22862, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22868, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74a50", - "kind": "EnumConstantDecl", - "name": "JUNGFRAU", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ea690", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22882, - "line": 749, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22929, - "line": 750, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e6ea5e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22886, - "line": 749, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22891, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ea5c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22888, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22888, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ea5a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22888, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22888, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6e9280", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22886, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22886, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ea590", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22891, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 22891, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6e92a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22891, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 22891, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"ChipTestBoard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ea680", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22916, - "line": 750, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22929, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e6ea650", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22923, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22929, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74aa8", - "kind": "EnumConstantDecl", - "name": "CHIPTESTBOARD", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ebac0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 22948, - "line": 751, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 22988, - "line": 752, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e6eba10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 22952, - "line": 751, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22957, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6eb9f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22954, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22954, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6eb9d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22954, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 22954, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ea6b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22952, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 22952, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6eb9c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 22957, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 22957, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ea6d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 22957, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 22957, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"Moench\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ebab0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 22975, - "line": 752, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 22988, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e6eba80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 22982, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 22988, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74b00", - "kind": "EnumConstantDecl", - "name": "MOENCH", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ecef0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23000, - "line": 753, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23041, - "line": 754, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6ece40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23004, - "line": 753, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23009, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ece28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23006, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23006, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ece08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23006, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23006, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ebae0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23004, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23004, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ecdf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23009, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23009, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ebb00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23009, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23009, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"Mythen3\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ecee0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23028, - "line": 754, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23041, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6eceb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23035, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23041, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74b58", - "kind": "EnumConstantDecl", - "name": "MYTHEN3", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ee320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23054, - "line": 755, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23097, - "line": 756, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6ee270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23058, - "line": 755, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23063, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ee258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23060, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23060, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ee238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23060, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23060, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ecf10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23058, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23058, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ee220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23063, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23063, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ecf30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23063, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23063, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"Gotthard2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ee310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23084, - "line": 756, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23097, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6ee2e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23091, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23097, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74bb0", - "kind": "EnumConstantDecl", - "name": "GOTTHARD2", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ef790", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23112, - "line": 757, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23166, - "line": 758, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e6ef6e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23116, - "line": 757, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23121, - "col": 14, - "tokLen": 22 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ef6c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ef6a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ee340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23116, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23116, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ef690", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23121, - "col": 14, - "tokLen": 22 - }, - "end": { - "offset": 23121, - "col": 14, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ee360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23121, - "col": 14, - "tokLen": 22 - }, - "end": { - "offset": 23121, - "col": 14, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Xilinx_ChipTestBoard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ef780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23153, - "line": 758, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23166, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e6ef750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23160, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23166, - "col": 22, - "tokLen": 20 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74c08", - "kind": "EnumConstantDecl", - "name": "XILINX_CHIPTESTBOARD", - "type": { - "qualType": "slsDetectorDefs::detectorType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6efdb8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 23192, - "line": 759, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e6efda0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 23192, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e6efd78", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 23198, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e6efd58", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 23198, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e6efd50", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e6efd20", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 23198, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 23239, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e6efd08", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e6efcf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e6efcd0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e6efcc8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e6efc90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6efc78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23236, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 23236, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6efc58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23236, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 23236, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e6efc40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23211, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ef7c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23211, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 23211, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown detector type \"" - } - ] - }, - { - "id": "0x564d8e6ef7f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23238, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 23238, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6e5330", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e6effb0", - "kind": "FunctionDecl", - "loc": { - "offset": 23280, - "file": "ToString.cpp", - "line": 762, - "col": 36, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 23245, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 24529, - "line": 804, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a6360", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16detectorSettingsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::detectorSettings (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "inner": [ - { - "id": "0x564d8dd58ab0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "decl": { - "id": "0x564d8dd58a08", - "kind": "EnumDecl", - "name": "detectorSettings" - } - } - ] - }, - { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "loc": { - "offset": 23308, - "line": 762, - "col": 64, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 23289, - "col": 45, - "tokLen": 5 - }, - "end": { - "offset": 23308, - "col": 64, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e709b78", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 23311, - "col": 67, - "tokLen": 1 - }, - "end": { - "offset": 24529, - "line": 804, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e6f15a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23317, - "line": 763, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23359, - "line": 764, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f14f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23321, - "line": 763, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23326, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f14d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23323, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23323, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f14b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23323, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23323, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f0198", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23321, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23321, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f14a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23326, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23326, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f01b8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23326, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23326, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"standard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f1590", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23346, - "line": 764, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23359, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f1560", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23353, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23359, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ad0", - "kind": "EnumConstantDecl", - "name": "STANDARD", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f29d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23373, - "line": 765, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23411, - "line": 766, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e6f2920", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23377, - "line": 765, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23382, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f2908", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23379, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23379, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f28e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23379, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23379, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f15c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23377, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23377, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f28d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23382, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 23382, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f15e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23382, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 23382, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"fast\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f29c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23398, - "line": 766, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23411, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e6f2990", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23405, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23411, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58b28", - "kind": "EnumConstantDecl", - "name": "FAST", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f3e00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23421, - "line": 767, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23463, - "line": 768, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f3d50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23425, - "line": 767, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23430, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f3d38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23427, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23427, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f3d18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23427, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23427, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f29f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23425, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23425, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f3d00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23430, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23430, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f2a10", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23430, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23430, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"highgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f3df0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23450, - "line": 768, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23463, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6f3dc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23457, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23463, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58b80", - "kind": "EnumConstantDecl", - "name": "HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f5230", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23477, - "line": 769, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23522, - "line": 770, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6f5180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23481, - "line": 769, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23486, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f5168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f5148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f3e20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23481, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23481, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f5130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23486, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23486, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f3e40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23486, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23486, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"dynamicgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f5220", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23509, - "line": 770, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23522, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6f51f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23516, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23522, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58bd8", - "kind": "EnumConstantDecl", - "name": "DYNAMICGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f6660", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23539, - "line": 771, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23580, - "line": 772, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6f65b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23543, - "line": 771, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23548, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f6598", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23545, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23545, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f6578", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23545, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23545, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f5250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23543, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23543, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f6560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23548, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23548, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f5270", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23548, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 23548, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"lowgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f6650", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23567, - "line": 772, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23580, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e6f6620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23574, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23580, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58c30", - "kind": "EnumConstantDecl", - "name": "LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f7a90", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23593, - "line": 773, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23637, - "line": 774, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e6f79e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23597, - "line": 773, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23602, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f79c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23599, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23599, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f79a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23599, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23599, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f6680", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23597, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23597, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f7990", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23602, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 23602, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f66a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23602, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 23602, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"mediumgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f7a80", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23624, - "line": 774, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23637, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e6f7a50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23631, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23637, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58c88", - "kind": "EnumConstantDecl", - "name": "MEDIUMGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6f8ec0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23653, - "line": 775, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23699, - "line": 776, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e6f8e10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23657, - "line": 775, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23662, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6f8df8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23659, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23659, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f8dd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23659, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23659, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f7ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23657, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23657, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6f8dc0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23662, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 23662, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f7ad0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23662, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 23662, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"veryhighgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6f8eb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23686, - "line": 776, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23699, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e6f8e80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23693, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23699, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ce0", - "kind": "EnumConstantDecl", - "name": "VERYHIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fa2f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23717, - "line": 777, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23760, - "line": 778, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6fa240", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23721, - "line": 777, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23726, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fa228", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23723, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23723, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fa208", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23723, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23723, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6f8ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23721, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23721, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fa1f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23726, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23726, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6f8f00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23726, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 23726, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"highgain0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fa2e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23747, - "line": 778, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23760, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e6fa2b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23754, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23760, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58d38", - "kind": "EnumConstantDecl", - "name": "HIGHGAIN0", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fb730", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23775, - "line": 779, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23817, - "line": 780, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fb680", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23779, - "line": 779, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23784, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fb668", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23781, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23781, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fb648", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23781, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23781, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fa310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23779, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23779, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fb630", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23784, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23784, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fa330", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23784, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23784, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"fixgain1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fb720", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23804, - "line": 780, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23817, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fb6f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23811, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23817, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58d90", - "kind": "EnumConstantDecl", - "name": "FIXGAIN1", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fcb60", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23831, - "line": 781, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23873, - "line": 782, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fcab0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23835, - "line": 781, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23840, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fca98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23837, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23837, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fca78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23837, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23837, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fb750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23835, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23835, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fca60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23840, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23840, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fb770", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23840, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 23840, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"fixgain2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fcb50", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23860, - "line": 782, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23873, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e6fcb20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23867, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23873, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58de8", - "kind": "EnumConstantDecl", - "name": "FIXGAIN2", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6fdf90", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23887, - "line": 783, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23932, - "line": 784, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6fdee0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23891, - "line": 783, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23896, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6fdec8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23893, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23893, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fdea8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23893, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23893, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fcb80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23891, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23891, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6fde90", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23896, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23896, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fcba0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23896, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 23896, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"verylowgain\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6fdf80", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23919, - "line": 784, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23932, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6fdf50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23926, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23932, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58e40", - "kind": "EnumConstantDecl", - "name": "VERYLOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e6ff3c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 23949, - "line": 785, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 23988, - "line": 786, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6ff310", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 23953, - "line": 785, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23958, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e6ff2f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23955, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23955, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ff2d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23955, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 23955, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6fdfb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23953, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 23953, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e6ff2c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 23958, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 23958, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6fdfd0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 23958, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 23958, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g1_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e6ff3b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 23975, - "line": 786, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 23988, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e6ff380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 23982, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 23988, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58e98", - "kind": "EnumConstantDecl", - "name": "G1_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7007f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24005, - "line": 787, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24044, - "line": 788, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e700740", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24009, - "line": 787, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24014, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e700728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24011, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24011, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e700708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24011, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24011, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e6ff3e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24009, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24009, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7006f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24014, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24014, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e6ff400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24014, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24014, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g1_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7007e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24031, - "line": 788, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24044, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7007b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24038, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24044, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ef0", - "kind": "EnumConstantDecl", - "name": "G1_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e701c20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24060, - "line": 789, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24102, - "line": 790, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e701b70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24064, - "line": 789, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24069, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e701b58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24066, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24066, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e701b38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24066, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24066, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e700810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24064, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24064, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e701b20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24069, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24069, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e700830", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24069, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24069, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_hc_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e701c10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24089, - "line": 790, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24102, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e701be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24096, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24102, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58f48", - "kind": "EnumConstantDecl", - "name": "G2_HIGHCAP_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e703050", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24127, - "line": 791, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24169, - "line": 792, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e702fa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24131, - "line": 791, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24136, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e702f88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24133, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24133, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e702f68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24133, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24133, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e701c40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24131, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24131, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e702f50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24136, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24136, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e701c60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24136, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24136, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_hc_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e703040", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24156, - "line": 792, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24169, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e703010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24163, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24169, - "col": 22, - "tokLen": 18 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58fa0", - "kind": "EnumConstantDecl", - "name": "G2_HIGHCAP_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e704480", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24193, - "line": 793, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24235, - "line": 794, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e7043d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24197, - "line": 793, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24202, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7043b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24199, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24199, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e704398", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24199, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24199, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e703070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24197, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24197, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e704380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24202, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24202, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e703090", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24202, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24202, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_lc_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e704470", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24222, - "line": 794, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24235, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e704440", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24229, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24235, - "col": 22, - "tokLen": 18 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58ff8", - "kind": "EnumConstantDecl", - "name": "G2_LOWCAP_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7058b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24259, - "line": 795, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24301, - "line": 796, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e705800", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24263, - "line": 795, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24268, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7057e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24265, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24265, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7057c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24265, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24265, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7044a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24263, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24263, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7057b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24268, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24268, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7044c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24268, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 24268, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"g2_lc_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7058a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24288, - "line": 796, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24301, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e705870", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24295, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24301, - "col": 22, - "tokLen": 17 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59050", - "kind": "EnumConstantDecl", - "name": "G2_LOWCAP_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e706ce0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24324, - "line": 797, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24363, - "line": 798, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e706c30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24328, - "line": 797, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24333, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e706c18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e706bf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7058d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24328, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24328, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e706be0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24333, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24333, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7058f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24333, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24333, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g4_hg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e706cd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24350, - "line": 798, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24363, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e706ca0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24357, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24363, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd590a8", - "kind": "EnumConstantDecl", - "name": "G4_HIGHGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e708110", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24380, - "line": 799, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24419, - "line": 800, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e708060", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24384, - "line": 799, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24389, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e708048", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24386, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24386, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e708028", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24386, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24386, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e706d00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24384, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24384, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e708010", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24389, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24389, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e706d20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24389, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24389, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"gain0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e708100", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24406, - "line": 800, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24419, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7080d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24413, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24419, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59158", - "kind": "EnumConstantDecl", - "name": "GAIN0", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e709540", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24430, - "line": 801, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24469, - "line": 802, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e709490", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24434, - "line": 801, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24439, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e709478", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24436, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24436, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e709458", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24436, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24436, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e708130", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24434, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24434, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e709440", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24439, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24439, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e708150", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24439, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 24439, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"g4_lg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e709530", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24456, - "line": 802, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24469, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e709500", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24463, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24469, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59100", - "kind": "EnumConstantDecl", - "name": "G4_LOWGAIN", - "type": { - "qualType": "slsDetectorDefs::detectorSettings" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e709b60", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 24485, - "line": 803, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e709b48", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 24485, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e709b20", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 24491, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e709b00", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 24491, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e709af8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e709ac8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 24491, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 24526, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e709ab0", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e709a98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e709a78", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e709a70", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e709a38", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e709a20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24523, - "col": 43, - "tokLen": 1 - }, - "end": { - "offset": 24523, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e709a00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24523, - "col": 43, - "tokLen": 1 - }, - "end": { - "offset": 24523, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7099e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24504, - "col": 24, - "tokLen": 18 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e709570", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24504, - "col": 24, - "tokLen": 18 - }, - "end": { - "offset": 24504, - "col": 24, - "tokLen": 18 - } - }, - "type": { - "qualType": "const char[17]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown setting \"" - } - ] - }, - { - "id": "0x564d8e709598", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24525, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 24525, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e6efed8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e709dc0", - "kind": "FunctionDecl", - "loc": { - "offset": 24561, - "file": "ToString.cpp", - "line": 806, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 24532, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 25086, - "line": 824, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a68f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10speedLevelEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::speedLevel (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "inner": [ - { - "id": "0x564d8dd59860", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "decl": { - "id": "0x564d8dd597b8", - "kind": "EnumDecl", - "name": "speedLevel" - } - } - ] - }, - { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "loc": { - "offset": 24589, - "line": 806, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 24570, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 24589, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e714748", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 24592, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 25086, - "line": 824, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e70b3c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24598, - "line": 807, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24642, - "line": 808, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70b310", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24602, - "line": 807, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24607, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70b2f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24604, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24604, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70b2d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24604, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24604, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e709fa8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24602, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24602, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70b2c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24607, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24607, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e709fc8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24607, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24607, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"full_speed\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70b3b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24629, - "line": 808, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24642, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70b380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24636, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24642, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59880", - "kind": "EnumConstantDecl", - "name": "FULL_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e70c7f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24658, - "line": 809, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24693, - "line": 810, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70c740", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24662, - "line": 809, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24667, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70c728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24664, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24664, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70c708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24664, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24664, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70b3e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24662, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24662, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70c6f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24667, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24667, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70b400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24667, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24667, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70c7e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24680, - "line": 810, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24693, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70c7b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24687, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24693, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59880", - "kind": "EnumConstantDecl", - "name": "FULL_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e70dc20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24709, - "line": 811, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24753, - "line": 812, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70db70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24713, - "line": 811, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24718, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70db58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24715, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24715, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70db38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24715, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24715, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70c810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24713, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24713, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70db20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24718, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24718, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70c830", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24718, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 24718, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"half_speed\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70dc10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24740, - "line": 812, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24753, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70dbe0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24747, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24753, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd598d8", - "kind": "EnumConstantDecl", - "name": "HALF_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e70f050", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24769, - "line": 813, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24804, - "line": 814, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70efa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24773, - "line": 813, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24778, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e70ef88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e70ef68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70dc40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24773, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24773, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e70ef50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24778, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24778, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70dc60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24778, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24778, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e70f040", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24791, - "line": 814, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24804, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e70f010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24798, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24804, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd598d8", - "kind": "EnumConstantDecl", - "name": "HALF_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e710480", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24820, - "line": 815, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24867, - "line": 816, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7103d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24824, - "line": 815, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24829, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7103b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24826, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24826, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e710398", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24826, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24826, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e70f070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24824, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24824, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e710380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24829, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 24829, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e70f090", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24829, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 24829, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"quarter_speed\"" - } - ] - } - ] - }, - { - "id": "0x564d8e710470", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24854, - "line": 816, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24867, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e710440", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24861, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24867, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59930", - "kind": "EnumConstantDecl", - "name": "QUARTER_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7118b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24886, - "line": 817, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24921, - "line": 818, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e711800", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24890, - "line": 817, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24895, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7117e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24892, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24892, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7117c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24892, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24892, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7104a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24890, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24890, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7117b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24895, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24895, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7104c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24895, - "col": 14, - "tokLen": 3 - }, - "end": { - "offset": 24895, - "col": 14, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7118a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24908, - "line": 818, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24921, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e711870", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24915, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24921, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59930", - "kind": "EnumConstantDecl", - "name": "QUARTER_SPEED", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e712ce0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24940, - "line": 819, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 24977, - "line": 820, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e712c30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24944, - "line": 819, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24949, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e712c18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24946, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24946, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e712bf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24946, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24946, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7118d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24944, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24944, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e712be0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24949, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 24949, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7118f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 24949, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 24949, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"108\"" - } - ] - } - ] - }, - { - "id": "0x564d8e712cd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 24964, - "line": 820, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 24977, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e712ca0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24971, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 24977, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59988", - "kind": "EnumConstantDecl", - "name": "G2_108MHZ", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e714110", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 24992, - "line": 821, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25029, - "line": 822, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e714060", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 24996, - "line": 821, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25001, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e714048", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 24998, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24998, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e714028", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24998, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 24998, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e712d00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 24996, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 24996, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e714010", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25001, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 25001, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e712d20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25001, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 25001, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"144\"" - } - ] - } - ] - }, - { - "id": "0x564d8e714100", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25016, - "line": 822, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25029, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7140d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25023, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25029, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::speedLevel" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd599e0", - "kind": "EnumConstantDecl", - "name": "G2_144MHZ", - "type": { - "qualType": "slsDetectorDefs::speedLevel" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e714730", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 25044, - "line": 823, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e714718", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 25044, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7146f0", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 25050, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7146d0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25050, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7146c8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e714698", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 25050, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25083, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e714680", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e714668", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e714648", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e714640", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e714608", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7145f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25080, - "col": 41, - "tokLen": 1 - }, - "end": { - "offset": 25080, - "col": 41, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7145d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25080, - "col": 41, - "tokLen": 1 - }, - "end": { - "offset": 25080, - "col": 41, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7145b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25063, - "col": 24, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e714140", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25063, - "col": 24, - "tokLen": 16 - }, - "end": { - "offset": 25063, - "col": 24, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown speed \"" - } - ] - }, - { - "id": "0x564d8e714168", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25082, - "col": 43, - "tokLen": 1 - }, - "end": { - "offset": 25082, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e709ce0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e714930", - "kind": "FunctionDecl", - "loc": { - "offset": 25118, - "file": "ToString.cpp", - "line": 826, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 25089, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 25505, - "line": 838, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a6e80", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10timingModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "inner": [ - { - "id": "0x564d8dd56080", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "decl": { - "id": "0x564d8dd55fd8", - "kind": "EnumDecl", - "name": "timingMode" - } - } - ] - }, - { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "loc": { - "offset": 25146, - "line": 826, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 25127, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 25146, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e71b630", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 25149, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 25505, - "line": 838, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e715f20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25155, - "line": 827, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25193, - "line": 828, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e715e70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25159, - "line": 827, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25164, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e715e58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25161, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25161, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e715e38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25161, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25161, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e714b18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25159, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25159, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e715e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25164, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25164, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e714b38", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25164, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25164, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"auto\"" - } - ] - } - ] - }, - { - "id": "0x564d8e715f10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25180, - "line": 828, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25193, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e715ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25187, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25193, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd560a0", - "kind": "EnumConstantDecl", - "name": "AUTO_TIMING", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e717350", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25210, - "line": 829, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25251, - "line": 830, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7172a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25214, - "line": 829, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25219, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e717288", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25216, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25216, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e717268", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25216, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25216, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e715f40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25214, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25214, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e717250", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25219, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 25219, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e715f60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25219, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 25219, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"trigger\"" - } - ] - } - ] - }, - { - "id": "0x564d8e717340", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25238, - "line": 830, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25251, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e717310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25245, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25251, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd560f8", - "kind": "EnumConstantDecl", - "name": "TRIGGER_EXPOSURE", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e718780", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25273, - "line": 831, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25313, - "line": 832, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7186d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25277, - "line": 831, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25282, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7186b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25279, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25279, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e718698", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25279, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25279, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e717370", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25277, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25277, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e718680", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25282, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25282, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e717390", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25282, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25282, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"gating\"" - } - ] - } - ] - }, - { - "id": "0x564d8e718770", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25300, - "line": 832, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25313, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e718740", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25307, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25313, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56150", - "kind": "EnumConstantDecl", - "name": "GATED", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e719bb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25324, - "line": 833, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25371, - "line": 834, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e719b00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25328, - "line": 833, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25333, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e719ae8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e719ac8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25330, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25330, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7187a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25328, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25328, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e719ab0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25333, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 25333, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7187c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25333, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 25333, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"burst_trigger\"" - } - ] - } - ] - }, - { - "id": "0x564d8e719ba0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25358, - "line": 834, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25371, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e719b70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25365, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25371, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd561a8", - "kind": "EnumConstantDecl", - "name": "BURST_TRIGGER", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71aff0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25390, - "line": 835, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25438, - "line": 836, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e71af40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25394, - "line": 835, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25399, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71af28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25396, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25396, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71af08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25396, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25396, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e719bd0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25394, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25394, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71aef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25399, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25399, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e719bf0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25399, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25399, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"trigger_gating\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71afe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25425, - "line": 836, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25438, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e71afb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25432, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25438, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56200", - "kind": "EnumConstantDecl", - "name": "TRIGGER_GATED", - "type": { - "qualType": "slsDetectorDefs::timingMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71b618", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 25457, - "line": 837, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e71b600", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 25457, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e71b5d8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 25463, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e71b5b8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25463, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71b5b0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71b580", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 25463, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25502, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e71b568", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e71b550", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e71b530", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71b528", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71b4f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71b4d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25499, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 25499, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71b4b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25499, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 25499, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e71b4a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25476, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71b020", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25476, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 25476, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown timing mode \"" - } - ] - }, - { - "id": "0x564d8e71b050", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25501, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 25501, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e714850", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e71b800", - "kind": "FunctionDecl", - "loc": { - "offset": 25545, - "file": "ToString.cpp", - "line": 840, - "col": 38, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 25508, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 25846, - "line": 848, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a7410", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18frameDiscardPolicyEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::frameDiscardPolicy (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "inner": [ - { - "id": "0x564d8dd540b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "decl": { - "id": "0x564d8dd54008", - "kind": "EnumDecl", - "name": "frameDiscardPolicy" - } - } - ] - }, - { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "loc": { - "offset": 25573, - "line": 840, - "col": 66, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 25554, - "col": 47, - "tokLen": 5 - }, - "end": { - "offset": 25573, - "col": 66, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e71fce0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 25576, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 25846, - "line": 848, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e71ce00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25582, - "line": 841, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25625, - "line": 842, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e71cd50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25586, - "line": 841, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25591, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71cd38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25588, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25588, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71cd18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25588, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25588, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e71b9e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25586, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25586, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71cd00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25591, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 25591, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71ba08", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25591, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 25591, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"nodiscard\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71cdf0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25612, - "line": 842, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25625, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e71cdc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25619, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25625, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd540d0", - "kind": "EnumConstantDecl", - "name": "NO_DISCARD", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71e230", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25641, - "line": 843, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25687, - "line": 844, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e71e180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25645, - "line": 843, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25650, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71e168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25647, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25647, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71e148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25647, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25647, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e71ce20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25645, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25645, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71e130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25650, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 25650, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71ce40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25650, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 25650, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"discardempty\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71e220", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25674, - "line": 844, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25687, - "col": 22, - "tokLen": 20 - } - }, - "inner": [ - { - "id": "0x564d8e71e1f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25681, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25687, - "col": 22, - "tokLen": 20 - } - }, - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd54128", - "kind": "EnumConstantDecl", - "name": "DISCARD_EMPTY_FRAMES", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71f660", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25713, - "line": 845, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25761, - "line": 846, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e71f5b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25717, - "line": 845, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25722, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71f598", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25719, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25719, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71f578", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25719, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25719, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e71e250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25717, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25717, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e71f560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25722, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25722, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71e270", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25722, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 25722, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"discardpartial\"" - } - ] - } - ] - }, - { - "id": "0x564d8e71f650", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25748, - "line": 846, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25761, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e71f620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25755, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25761, - "col": 22, - "tokLen": 22 - } - }, - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd54180", - "kind": "EnumConstantDecl", - "name": "DISCARD_PARTIAL_FRAMES", - "type": { - "qualType": "slsDetectorDefs::frameDiscardPolicy" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e71fcc8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 25789, - "line": 847, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e71fcb0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 25789, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e71fc88", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 25795, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e71fc68", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25795, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71fc60", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71fc30", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 25795, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 25843, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e71fc18", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e71fc00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e71fbe0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e71fbd8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e71fba0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e71fb88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25840, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 25840, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e71fb68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25840, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 25840, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e71fb50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25808, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e71f690", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25808, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 25808, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char[30]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown frame discard policy \"" - } - ] - }, - { - "id": "0x564d8e71f6c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25842, - "col": 58, - "tokLen": 1 - }, - "end": { - "offset": 25842, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71b720", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e71fea0", - "kind": "FunctionDecl", - "loc": { - "offset": 25878, - "file": "ToString.cpp", - "line": 850, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 25849, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 26063, - "line": 856, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a79a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10fileFormatEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::fileFormat (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "inner": [ - { - "id": "0x564d8dd542d0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "decl": { - "id": "0x564d8dd54230", - "kind": "EnumDecl", - "name": "fileFormat" - } - } - ] - }, - { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "loc": { - "offset": 25906, - "line": 850, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 25887, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 25906, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e722f00", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 25909, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 26063, - "line": 856, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e721490", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25915, - "line": 851, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 25953, - "line": 852, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7213e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25919, - "line": 851, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25924, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7213c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25921, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25921, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7213a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25921, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25921, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e720088", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25919, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25919, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e721390", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25924, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25924, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7200a8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25924, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 25924, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"hdf5\"" - } - ] - } - ] - }, - { - "id": "0x564d8e721480", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25940, - "line": 852, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 25953, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e721450", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25947, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 25953, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd54348", - "kind": "EnumConstantDecl", - "name": "HDF5", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7228c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 25963, - "line": 853, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26003, - "line": 854, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e722810", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 25967, - "line": 853, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25972, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7227f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25969, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25969, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7227d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25969, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 25969, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7214b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25967, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 25967, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7227c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 25972, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25972, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7214d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 25972, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 25972, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"binary\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7228b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 25990, - "line": 854, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26003, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e722880", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 25997, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26003, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::fileFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd542f0", - "kind": "EnumConstantDecl", - "name": "BINARY", - "type": { - "qualType": "slsDetectorDefs::fileFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e722ee8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 26015, - "line": 855, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e722ed0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 26015, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e722ea8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 26021, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e722e88", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26021, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e722e80", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e722e50", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 26021, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26060, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e722e38", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e722e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e722e00", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e722df8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e722dc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e722da8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26057, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 26057, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e722d88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26057, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 26057, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e722d70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26034, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7228f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26034, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 26034, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown file format \"" - } - ] - }, - { - "id": "0x564d8e722920", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26059, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 26059, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e71fdc0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7230b0", - "kind": "FunctionDecl", - "loc": { - "offset": 26103, - "file": "ToString.cpp", - "line": 858, - "col": 38, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 26066, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 26497, - "line": 868, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a7f30", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18externalSignalFlagEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::externalSignalFlag (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "inner": [ - { - "id": "0x564d8dd55e30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "decl": { - "id": "0x564d8dd55d88", - "kind": "EnumDecl", - "name": "externalSignalFlag" - } - } - ] - }, - { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "loc": { - "offset": 26131, - "line": 858, - "col": 66, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 26112, - "col": 47, - "tokLen": 5 - }, - "end": { - "offset": 26131, - "col": 66, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e728998", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 26134, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 26497, - "line": 868, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7246b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26140, - "line": 859, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26196, - "line": 860, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e724600", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26144, - "line": 859, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26149, - "col": 14, - "tokLen": 24 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7245e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26146, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26146, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7245c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26146, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26146, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e723298", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26144, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26144, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7245b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26149, - "col": 14, - "tokLen": 24 - }, - "end": { - "offset": 26149, - "col": 14, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7232b8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26149, - "col": 14, - "tokLen": 24 - }, - "end": { - "offset": 26149, - "col": 14, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"trigger_in_rising_edge\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7246a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26183, - "line": 860, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26196, - "col": 22, - "tokLen": 22 - } - }, - "inner": [ - { - "id": "0x564d8e724670", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26190, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26196, - "col": 22, - "tokLen": 22 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55e50", - "kind": "EnumConstantDecl", - "name": "TRIGGER_IN_RISING_EDGE", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e725af0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26224, - "line": 861, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26281, - "line": 862, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e725a40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26228, - "line": 861, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26233, - "col": 14, - "tokLen": 25 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e725a28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26230, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26230, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e725a08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26230, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26230, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7246d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26228, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26228, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7259f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26233, - "col": 14, - "tokLen": 25 - }, - "end": { - "offset": 26233, - "col": 14, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7246f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26233, - "col": 14, - "tokLen": 25 - }, - "end": { - "offset": 26233, - "col": 14, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char[24]" - }, - "valueCategory": "lvalue", - "value": "\"trigger_in_falling_edge\"" - } - ] - } - ] - }, - { - "id": "0x564d8e725ae0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26268, - "line": 862, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26281, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e725ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26275, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26281, - "col": 22, - "tokLen": 23 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55ea8", - "kind": "EnumConstantDecl", - "name": "TRIGGER_IN_FALLING_EDGE", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e726f20", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26310, - "line": 863, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26356, - "line": 864, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e726e70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26314, - "line": 863, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26319, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e726e58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26316, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26316, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e726e38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26316, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26316, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e725b10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26314, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26314, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e726e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26319, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 26319, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e725b30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26319, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 26319, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"inversion_on\"" - } - ] - } - ] - }, - { - "id": "0x564d8e726f10", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26343, - "line": 864, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26356, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e726ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26350, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26356, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55f00", - "kind": "EnumConstantDecl", - "name": "INVERSION_ON", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e728350", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26374, - "line": 865, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26421, - "line": 866, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7282a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26378, - "line": 865, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26383, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e728288", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e728268", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e726f40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26378, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26378, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e728250", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26383, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 26383, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e726f60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26383, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 26383, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"inversion_off\"" - } - ] - } - ] - }, - { - "id": "0x564d8e728340", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26408, - "line": 866, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26421, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e728310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26415, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26421, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd55f58", - "kind": "EnumConstantDecl", - "name": "INVERSION_OFF", - "type": { - "qualType": "slsDetectorDefs::externalSignalFlag" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e728980", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 26440, - "line": 867, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e728968", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 26440, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e728940", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 26446, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e728920", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26446, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e728918", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7288e8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 26446, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26494, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7288d0", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7288b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e728898", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e728890", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e728858", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e728840", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26491, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 26491, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e728820", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26491, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 26491, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e728808", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26459, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e728380", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26459, - "col": 24, - "tokLen": 31 - }, - "end": { - "offset": 26459, - "col": 24, - "tokLen": 31 - } - }, - "type": { - "qualType": "const char[30]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown external signal flag \"" - } - ] - }, - { - "id": "0x564d8e7283b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26493, - "col": 58, - "tokLen": 1 - }, - "end": { - "offset": 26493, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e722fd8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e728b60", - "kind": "FunctionDecl", - "loc": { - "offset": 26530, - "file": "ToString.cpp", - "line": 870, - "col": 31, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 26500, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 26953, - "line": 882, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a84c0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11readoutModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::readoutMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "inner": [ - { - "id": "0x564d8dd595b0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "decl": { - "id": "0x564d8dd59508", - "kind": "EnumDecl", - "name": "readoutMode" - } - } - ] - }, - { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "loc": { - "offset": 26558, - "line": 870, - "col": 59, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 26539, - "col": 40, - "tokLen": 5 - }, - "end": { - "offset": 26558, - "col": 59, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e72f890", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 26561, - "col": 62, - "tokLen": 1 - }, - "end": { - "offset": 26953, - "line": 882, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e72a150", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26567, - "line": 871, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26607, - "line": 872, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e72a0a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26571, - "line": 871, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26576, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72a088", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26573, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26573, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72a068", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26573, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26573, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e728d48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26571, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26571, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72a050", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26576, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 26576, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e728d68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26576, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 26576, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"analog\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72a140", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26594, - "line": 872, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26607, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e72a110", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26601, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26607, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd595d0", - "kind": "EnumConstantDecl", - "name": "ANALOG_ONLY", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72b580", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26624, - "line": 873, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26665, - "line": 874, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e72b4d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26628, - "line": 873, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26633, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72b4b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26630, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26630, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72b498", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26630, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26630, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72a170", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26628, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26628, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72b480", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26633, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 26633, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72a190", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26633, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 26633, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"digital\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72b570", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26652, - "line": 874, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26665, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e72b540", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26659, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26665, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59628", - "kind": "EnumConstantDecl", - "name": "DIGITAL_ONLY", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72c9b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26683, - "line": 875, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26731, - "line": 876, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e72c900", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26687, - "line": 875, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26692, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72c8e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26689, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26689, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72c8c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26689, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26689, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72b5a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26687, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26687, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72c8b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26692, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 26692, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72b5c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26692, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 26692, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"analog_digital\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72c9a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26718, - "line": 876, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26731, - "col": 22, - "tokLen": 18 - } - }, - "inner": [ - { - "id": "0x564d8e72c970", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26725, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26731, - "col": 22, - "tokLen": 18 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59680", - "kind": "EnumConstantDecl", - "name": "ANALOG_AND_DIGITAL", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72dde0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26755, - "line": 877, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26800, - "line": 878, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e72dd30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26759, - "line": 877, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26764, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72dd18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26761, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26761, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72dcf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26761, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26761, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72c9d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26759, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26759, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72dce0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26764, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 26764, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72c9f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26764, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 26764, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"transceiver\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72ddd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26787, - "line": 878, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26800, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e72dda0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26794, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26800, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd596d8", - "kind": "EnumConstantDecl", - "name": "TRANSCEIVER_ONLY", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72f220", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 26822, - "line": 879, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 26875, - "line": 880, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e72f170", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26826, - "line": 879, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26831, - "col": 14, - "tokLen": 21 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72f158", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26828, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26828, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72f138", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26828, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 26828, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72de00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26826, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 26826, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e72f120", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26831, - "col": 14, - "tokLen": 21 - }, - "end": { - "offset": 26831, - "col": 14, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72de20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26831, - "col": 14, - "tokLen": 21 - }, - "end": { - "offset": 26831, - "col": 14, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char[20]" - }, - "valueCategory": "lvalue", - "value": "\"digital_transceiver\"" - } - ] - } - ] - }, - { - "id": "0x564d8e72f210", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 26862, - "line": 880, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 26875, - "col": 22, - "tokLen": 23 - } - }, - "inner": [ - { - "id": "0x564d8e72f1e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26869, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 26875, - "col": 22, - "tokLen": 23 - } - }, - "type": { - "qualType": "slsDetectorDefs::readoutMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59730", - "kind": "EnumConstantDecl", - "name": "DIGITAL_AND_TRANSCEIVER", - "type": { - "qualType": "slsDetectorDefs::readoutMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e72f878", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 26904, - "line": 881, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e72f860", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 26904, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e72f838", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 26910, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e72f818", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26910, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e72f810", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e72f7e0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 26910, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 26950, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e72f7c8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e72f7b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e72f790", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e72f788", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e72f750", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e72f738", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26947, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 26947, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e72f718", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26947, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 26947, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e72f700", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26923, - "col": 24, - "tokLen": 23 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72f250", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 26923, - "col": 24, - "tokLen": 23 - }, - "end": { - "offset": 26923, - "col": 24, - "tokLen": 23 - } - }, - "type": { - "qualType": "const char[22]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown readout mode \"" - } - ] - }, - { - "id": "0x564d8e72f280", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 26949, - "col": 50, - "tokLen": 1 - }, - "end": { - "offset": 26949, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e728a80", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e72fa60", - "kind": "FunctionDecl", - "loc": { - "offset": 26983, - "file": "ToString.cpp", - "line": 884, - "col": 28, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 26956, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 32146, - "line": 1062, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a8a50", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8dacIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::dacIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "inner": [ - { - "id": "0x564d8dd56380", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "decl": { - "id": "0x564d8dd562d8", - "kind": "EnumDecl", - "name": "dacIndex" - } - } - ] - }, - { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "loc": { - "offset": 27011, - "line": 884, - "col": 56, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 26992, - "col": 37, - "tokLen": 5 - }, - "end": { - "offset": 27011, - "col": 56, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7b55f0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 27014, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 32146, - "line": 1062, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e732400", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27020, - "line": 885, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27071, - "line": 886, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e732368", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27024, - "line": 885, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e730fa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27024, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27029, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e730f88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e730f68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e72fc48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27024, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27024, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e730f50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27029, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27029, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e72fc68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27029, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27029, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e732330", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27040, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e732318", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27042, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27042, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7322f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27042, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27042, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e730fd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27040, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27040, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7322e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27045, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e730ff8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27045, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27045, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"0\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7323f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27058, - "line": 886, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27071, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7323c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27065, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27071, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd563a0", - "kind": "EnumConstantDecl", - "name": "DAC_0", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e734be0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27082, - "line": 887, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27133, - "line": 888, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e734b48", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27086, - "line": 887, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e733780", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27086, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27091, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e733768", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27088, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27088, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e733748", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27088, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27088, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e732420", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27086, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27086, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e733730", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27091, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27091, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e732440", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27091, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27091, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e734b10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27102, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e734af8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27104, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27104, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e734ad8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27104, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27104, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7337b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27102, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27102, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e734ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27107, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7337d8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27107, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27107, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"1\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e734bd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27120, - "line": 888, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27133, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e734ba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27127, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27133, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd563f8", - "kind": "EnumConstantDecl", - "name": "DAC_1", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7373c0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27144, - "line": 889, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27195, - "line": 890, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e737328", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27148, - "line": 889, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e735f60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27148, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27153, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e735f48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27150, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27150, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e735f28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27150, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27150, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e734c00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27148, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27148, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e735f10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27153, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27153, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e734c20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27153, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27153, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7372f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27164, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7372d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27166, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27166, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7372b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27166, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27166, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e735f98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27164, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27164, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7372a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27169, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e735fb8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27169, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27169, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"2\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7373b0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27182, - "line": 890, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27195, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e737380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27189, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27195, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56450", - "kind": "EnumConstantDecl", - "name": "DAC_2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e739ba0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27206, - "line": 891, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27257, - "line": 892, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e739b08", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27210, - "line": 891, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e738740", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27210, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27215, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e738728", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e738708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7373e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27210, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27210, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7386f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27215, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27215, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e737400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27215, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27215, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 3\"" - } - ] - } - ] - }, - { - "id": "0x564d8e739ad0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27226, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e739ab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27228, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27228, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e739a98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27228, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27228, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e738778", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27226, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27226, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e739a80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27231, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e738798", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27231, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27231, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"3\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e739b90", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27244, - "line": 892, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27257, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e739b60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27251, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27257, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd564a8", - "kind": "EnumConstantDecl", - "name": "DAC_3", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e73c390", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27268, - "line": 893, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27319, - "line": 894, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73c2f8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27272, - "line": 893, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e73af30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27272, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27277, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73af18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27274, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27274, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73aef8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27274, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27274, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e739bc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27272, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27272, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73aee0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27277, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27277, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e739be0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27277, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27277, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 4\"" - } - ] - } - ] - }, - { - "id": "0x564d8e73c2c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27288, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73c2a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27290, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27290, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73c288", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27290, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27290, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73af68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27288, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27288, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73c270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27293, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73af88", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27293, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27293, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"4\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e73c380", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27306, - "line": 894, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27319, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73c350", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27313, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27319, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56500", - "kind": "EnumConstantDecl", - "name": "DAC_4", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e73eb70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27330, - "line": 895, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27381, - "line": 896, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73ead8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27334, - "line": 895, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e73d710", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27334, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27339, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73d6f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27336, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27336, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73d6d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27336, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27336, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73c3b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27334, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27334, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73d6c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27339, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27339, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73c3d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27339, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27339, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 5\"" - } - ] - } - ] - }, - { - "id": "0x564d8e73eaa0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27350, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73ea88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27352, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27352, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73ea68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27352, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27352, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73d748", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27350, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27350, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73ea50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27355, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73d768", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27355, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27355, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"5\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e73eb60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27368, - "line": 896, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27381, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e73eb30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27375, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27381, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56558", - "kind": "EnumConstantDecl", - "name": "DAC_5", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e741350", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27392, - "line": 897, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27443, - "line": 898, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7412b8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27396, - "line": 897, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e73fef0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27396, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27401, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e73fed8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27398, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27398, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e73feb8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27398, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27398, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73eb90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27396, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27396, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e73fea0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27401, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27401, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73ebb0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27401, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27401, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 6\"" - } - ] - } - ] - }, - { - "id": "0x564d8e741280", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27412, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e741268", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27414, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27414, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e741248", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27414, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27414, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e73ff28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27412, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27412, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e741230", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27417, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e73ff48", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27417, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27417, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"6\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e741340", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27430, - "line": 898, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27443, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e741310", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27437, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27443, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd565b0", - "kind": "EnumConstantDecl", - "name": "DAC_6", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e743b30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27454, - "line": 899, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27505, - "line": 900, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e743a98", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27458, - "line": 899, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7426d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27458, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27463, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7426b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27460, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27460, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e742698", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27460, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27460, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e741370", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27458, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27458, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e742680", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27463, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27463, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e741390", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27463, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27463, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 7\"" - } - ] - } - ] - }, - { - "id": "0x564d8e743a60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27474, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e743a48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27476, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27476, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e743a28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27476, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27476, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e742708", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27474, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27474, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e743a10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27479, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e742728", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27479, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27479, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"7\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e743b20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27492, - "line": 900, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27505, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e743af0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27499, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27505, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56608", - "kind": "EnumConstantDecl", - "name": "DAC_7", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e746310", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27516, - "line": 901, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27567, - "line": 902, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e746278", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27520, - "line": 901, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e744eb0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27520, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27525, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e744e98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27522, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27522, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e744e78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27522, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27522, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e743b50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27520, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27520, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e744e60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27525, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27525, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e743b70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27525, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27525, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 8\"" - } - ] - } - ] - }, - { - "id": "0x564d8e746240", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27536, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e746228", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27538, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27538, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e746208", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27538, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27538, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e744ee8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27536, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27536, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7461f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27541, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e744f08", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27541, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27541, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"8\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e746300", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27554, - "line": 902, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27567, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7462d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27561, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27567, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56660", - "kind": "EnumConstantDecl", - "name": "DAC_8", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e748af0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27578, - "line": 903, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27629, - "line": 904, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e748a58", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27582, - "line": 903, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e747690", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27587, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e747678", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e747658", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e746330", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27582, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e747640", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27587, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27587, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e746350", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27587, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 27587, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"dac 9\"" - } - ] - } - ] - }, - { - "id": "0x564d8e748a20", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27598, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e748a08", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27600, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27600, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7489e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27600, - "col": 27, - "tokLen": 2 - }, - "end": { - "offset": 27600, - "col": 27, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7476c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27598, - "col": 25, - "tokLen": 1 - }, - "end": { - "offset": 27598, - "col": 25, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7489d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27603, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7476e8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27603, - "col": 30, - "tokLen": 3 - }, - "end": { - "offset": 27603, - "col": 30, - "tokLen": 3 - } - }, - "type": { - "qualType": "const char[2]" - }, - "valueCategory": "lvalue", - "value": "\"9\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e748ae0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27616, - "line": 904, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27629, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e748ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27623, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27629, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd566b8", - "kind": "EnumConstantDecl", - "name": "DAC_9", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e74b2d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27640, - "line": 905, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27693, - "line": 906, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74b238", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27644, - "line": 905, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e749e70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27644, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27649, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e749e58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27646, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27646, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e749e38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27646, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27646, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e748b10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27644, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27644, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e749e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27649, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27649, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e748b30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27649, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27649, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 10\"" - } - ] - } - ] - }, - { - "id": "0x564d8e74b200", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27661, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74b1e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27663, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27663, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74b1c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27663, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27663, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e749ea8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27661, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27661, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74b1b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27666, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e749ec8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27666, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27666, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"10\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e74b2c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27680, - "line": 906, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27693, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74b290", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27687, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27693, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56710", - "kind": "EnumConstantDecl", - "name": "DAC_10", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e74dab0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27705, - "line": 907, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27758, - "line": 908, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74da18", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27709, - "line": 907, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e74c650", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27709, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27714, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74c638", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27711, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27711, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74c618", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27711, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27711, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74b2f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27709, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27709, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74c600", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27714, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27714, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74b310", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27714, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27714, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 11\"" - } - ] - } - ] - }, - { - "id": "0x564d8e74d9e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27726, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74d9c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27728, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27728, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74d9a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27728, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27728, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74c688", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27726, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27726, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74d990", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27731, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74c6a8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27731, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27731, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"11\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e74daa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27745, - "line": 908, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27758, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e74da70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27752, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27758, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56768", - "kind": "EnumConstantDecl", - "name": "DAC_11", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e750290", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27770, - "line": 909, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27823, - "line": 910, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7501f8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27774, - "line": 909, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e74ee30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27774, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27779, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e74ee18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e74edf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27776, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27776, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74dad0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27774, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27774, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e74ede0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27779, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27779, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74daf0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27779, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27779, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 12\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7501c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27791, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7501a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27793, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27793, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e750188", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27793, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27793, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e74ee68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27791, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27791, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e750170", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27796, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e74ee88", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27796, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27796, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"12\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e750280", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27810, - "line": 910, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27823, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e750250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27817, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27823, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd567c0", - "kind": "EnumConstantDecl", - "name": "DAC_12", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e752a70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27835, - "line": 911, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27888, - "line": 912, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7529d8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27839, - "line": 911, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e751610", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27839, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27844, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7515f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27841, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27841, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7515d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27841, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27841, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7502b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27839, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27839, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7515c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27844, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27844, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7502d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27844, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27844, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 13\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7529a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27856, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e752988", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27858, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27858, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e752968", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27858, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27858, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e751648", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27856, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27856, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e752950", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27861, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e751668", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27861, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27861, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"13\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e752a60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27875, - "line": 912, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27888, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e752a30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27882, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27888, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56818", - "kind": "EnumConstantDecl", - "name": "DAC_13", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e755250", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27900, - "line": 913, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 27953, - "line": 914, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7551b8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27904, - "line": 913, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e753df0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27904, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27909, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e753dd8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27906, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27906, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e753db8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27906, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27906, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e752a90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27904, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27904, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e753da0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27909, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27909, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e752ab0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27909, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27909, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 14\"" - } - ] - } - ] - }, - { - "id": "0x564d8e755180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27921, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e755168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27923, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27923, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e755148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27923, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27923, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e753e28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27921, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27921, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e755130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27926, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e753e48", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27926, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27926, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"14\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e755240", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 27940, - "line": 914, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 27953, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e755210", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27947, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 27953, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56870", - "kind": "EnumConstantDecl", - "name": "DAC_14", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e757a30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 27965, - "line": 915, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28018, - "line": 916, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e757998", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 27969, - "line": 915, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7565d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27969, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27974, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7565b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27971, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27971, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e756598", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27971, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 27971, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e755270", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27969, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 27969, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e756580", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27974, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27974, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e755290", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27974, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 27974, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 15\"" - } - ] - } - ] - }, - { - "id": "0x564d8e757960", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 27986, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e757948", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27988, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27988, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e757928", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27988, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 27988, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e756608", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 27986, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 27986, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e757910", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 27991, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e756628", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 27991, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 27991, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"15\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e757a20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28005, - "line": 916, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28018, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7579f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28012, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28018, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd568c8", - "kind": "EnumConstantDecl", - "name": "DAC_15", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75a210", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28030, - "line": 917, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28083, - "line": 918, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75a178", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 28034, - "line": 917, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e758db0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28034, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28039, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e758d98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28036, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28036, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e758d78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28036, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28036, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e757a50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28034, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28034, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e758d60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28039, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28039, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e757a70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28039, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28039, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 16\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75a140", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28051, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75a128", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28053, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28053, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75a108", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28053, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28053, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e758de8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28051, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28051, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75a0f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28056, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e758e08", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28056, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28056, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"16\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e75a200", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28070, - "line": 918, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28083, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75a1d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28077, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28083, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56920", - "kind": "EnumConstantDecl", - "name": "DAC_16", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75ca40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28095, - "line": 919, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28148, - "line": 920, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75c9a8", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 28099, - "line": 919, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e75b5e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28099, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28104, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75b5c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28101, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28101, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75b5a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28101, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28101, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75a230", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28099, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28099, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75b590", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28104, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28104, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75a250", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28104, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28104, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"dac 17\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75c970", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28116, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75c958", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28118, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28118, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75c938", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28118, - "col": 28, - "tokLen": 2 - }, - "end": { - "offset": 28118, - "col": 28, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75b618", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28116, - "col": 26, - "tokLen": 1 - }, - "end": { - "offset": 28116, - "col": 26, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75c920", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28121, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75b638", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28121, - "col": 31, - "tokLen": 4 - }, - "end": { - "offset": 28121, - "col": 31, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"17\"" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e75ca30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28135, - "line": 920, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28148, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e75ca00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28142, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28148, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56978", - "kind": "EnumConstantDecl", - "name": "DAC_17", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75de70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28160, - "line": 921, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28198, - "line": 922, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e75ddc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28164, - "line": 921, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28169, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75dda8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28166, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28166, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75dd88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28166, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28166, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75ca60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28164, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28164, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75dd70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28169, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28169, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75ca80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28169, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28169, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vsvp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75de60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28185, - "line": 922, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28198, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e75de30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28192, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28198, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd569d0", - "kind": "EnumConstantDecl", - "name": "VSVP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e75f2a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28208, - "line": 923, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28247, - "line": 924, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e75f1f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28212, - "line": 923, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28217, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e75f1d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28214, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28214, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e75f1b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28214, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28214, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75de90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28212, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28212, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e75f1a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28217, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 28217, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75deb0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28217, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 28217, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vtrim\"" - } - ] - } - ] - }, - { - "id": "0x564d8e75f290", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28234, - "line": 924, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28247, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e75f260", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28241, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28247, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56a28", - "kind": "EnumConstantDecl", - "name": "VTRIM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7606d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28258, - "line": 925, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28300, - "line": 926, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e760620", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28262, - "line": 925, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28267, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e760608", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28264, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28264, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7605e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28264, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28264, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e75f2c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28262, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28262, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7605d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28267, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28267, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e75f2e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28267, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28267, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vrpreamp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7606c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28287, - "line": 926, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28300, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e760690", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28294, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28300, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56a80", - "kind": "EnumConstantDecl", - "name": "VRPREAMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e761b00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28314, - "line": 927, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28356, - "line": 928, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e761a50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28318, - "line": 927, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28323, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e761a38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28320, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28320, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e761a18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28320, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28320, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7606f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28318, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28318, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e761a00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28323, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28323, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e760710", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28323, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28323, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vrshaper\"" - } - ] - } - ] - }, - { - "id": "0x564d8e761af0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28343, - "line": 928, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28356, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e761ac0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28350, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28356, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ad8", - "kind": "EnumConstantDecl", - "name": "VRSHAPER", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e762f30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28370, - "line": 929, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28408, - "line": 930, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e762e80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28374, - "line": 929, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28379, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e762e68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28376, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28376, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e762e48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28376, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28376, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e761b20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28374, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28374, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e762e30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28379, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28379, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e761b40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28379, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28379, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vsvn\"" - } - ] - } - ] - }, - { - "id": "0x564d8e762f20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28395, - "line": 930, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28408, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e762ef0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28402, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28408, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56b30", - "kind": "EnumConstantDecl", - "name": "VSVN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e764360", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28418, - "line": 931, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28458, - "line": 932, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7642b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28422, - "line": 931, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28427, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e764298", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28424, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28424, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e764278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28424, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28424, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e762f50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28422, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28422, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e764260", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28427, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28427, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e762f70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28427, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28427, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vtgstv\"" - } - ] - } - ] - }, - { - "id": "0x564d8e764350", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28445, - "line": 932, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28458, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e764320", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28452, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28458, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56b88", - "kind": "EnumConstantDecl", - "name": "VTGSTV", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e765790", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28470, - "line": 933, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28511, - "line": 934, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7656e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28474, - "line": 933, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28479, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7656c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28476, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28476, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7656a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28476, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28476, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e764380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28474, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28474, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e765690", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28479, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28479, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7643a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28479, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28479, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_ll\"" - } - ] - } - ] - }, - { - "id": "0x564d8e765780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28498, - "line": 934, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28511, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e765750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28505, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28511, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56be0", - "kind": "EnumConstantDecl", - "name": "VCMP_LL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e766bc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28524, - "line": 935, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28565, - "line": 936, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e766b10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28528, - "line": 935, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28533, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e766af8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28530, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28530, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e766ad8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28530, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28530, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7657b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28528, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28528, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e766ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28533, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28533, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7657d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28533, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28533, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_lr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e766bb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28552, - "line": 936, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28565, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e766b80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28559, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28565, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56c38", - "kind": "EnumConstantDecl", - "name": "VCMP_LR", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e767ff0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28578, - "line": 937, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28616, - "line": 938, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e767f40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28582, - "line": 937, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e767f28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e767f08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e766be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28582, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e767ef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e766c00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 28587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vcal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e767fe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28603, - "line": 938, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28616, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e767fb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28610, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28616, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56c90", - "kind": "EnumConstantDecl", - "name": "VCAL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e769420", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28626, - "line": 939, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28667, - "line": 940, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e769370", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28630, - "line": 939, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28635, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e769358", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e769338", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e768010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28630, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28630, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e769320", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28635, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28635, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e768030", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28635, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28635, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_rl\"" - } - ] - } - ] - }, - { - "id": "0x564d8e769410", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28654, - "line": 940, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28667, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7693e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28661, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28667, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ce8", - "kind": "EnumConstantDecl", - "name": "VCMP_RL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76a850", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28680, - "line": 941, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28720, - "line": 942, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76a7a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28684, - "line": 941, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28689, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76a788", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28686, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28686, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76a768", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28686, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28686, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e769440", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28684, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28684, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76a750", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28689, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28689, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e769460", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28689, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28689, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"rxb_rb\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76a840", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28707, - "line": 942, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28720, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76a810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28714, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28720, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56d40", - "kind": "EnumConstantDecl", - "name": "RXB_RB", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76bc80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28732, - "line": 943, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28772, - "line": 944, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76bbd0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28736, - "line": 943, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28741, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76bbb8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28738, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28738, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76bb98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28738, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28738, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76a870", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28736, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28736, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76bb80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28741, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28741, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76a890", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28741, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 28741, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"rxb_lb\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76bc70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28759, - "line": 944, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28772, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e76bc40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28766, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28772, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56d98", - "kind": "EnumConstantDecl", - "name": "RXB_LB", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76d0b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28784, - "line": 945, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28825, - "line": 946, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e76d000", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28788, - "line": 945, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28793, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76cfe8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28790, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28790, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76cfc8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28790, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28790, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76bca0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28788, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28788, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76cfb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28793, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28793, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76bcc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28793, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 28793, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vcmp_rr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76d0a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28812, - "line": 946, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28825, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e76d070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28819, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28825, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56df0", - "kind": "EnumConstantDecl", - "name": "VCMP_RR", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76e4e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28838, - "line": 947, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28875, - "line": 948, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76e430", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28842, - "line": 947, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28847, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76e418", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28844, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28844, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76e3f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28844, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28844, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76d0d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28842, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28842, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76e3e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28847, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28847, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76d0f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28847, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28847, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"vcp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76e4d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28862, - "line": 948, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28875, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76e4a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28869, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28875, - "col": 22, - "tokLen": 3 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56e48", - "kind": "EnumConstantDecl", - "name": "VCP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e76f910", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28884, - "line": 949, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28921, - "line": 950, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76f860", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28888, - "line": 949, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28893, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e76f848", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28890, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28890, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e76f828", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28890, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28890, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76e500", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28888, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28888, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e76f810", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28893, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28893, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76e520", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28893, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 28893, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"vcn\"" - } - ] - } - ] - }, - { - "id": "0x564d8e76f900", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28908, - "line": 950, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28921, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e76f8d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28915, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28921, - "col": 22, - "tokLen": 3 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ea0", - "kind": "EnumConstantDecl", - "name": "VCN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e770d40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28930, - "line": 951, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 28972, - "line": 952, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e770c90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28934, - "line": 951, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28939, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e770c78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28936, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28936, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e770c58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28936, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28936, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e76f930", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28934, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28934, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e770c40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28939, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28939, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e76f950", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28939, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 28939, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vishaper\"" - } - ] - } - ] - }, - { - "id": "0x564d8e770d30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 28959, - "line": 952, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 28972, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e770d00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28966, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 28972, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56ef8", - "kind": "EnumConstantDecl", - "name": "VISHAPER", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e772170", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 28986, - "line": 953, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29030, - "line": 954, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7720c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 28990, - "line": 953, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28995, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7720a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e772088", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 28992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e770d60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 28990, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 28990, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e772070", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 28995, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 28995, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e770d80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 28995, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 28995, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vthreshold\"" - } - ] - } - ] - }, - { - "id": "0x564d8e772160", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29017, - "line": 954, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29030, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e772130", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29024, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29030, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56f50", - "kind": "EnumConstantDecl", - "name": "VTHRESHOLD", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7735a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29046, - "line": 955, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29087, - "line": 956, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7734f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29050, - "line": 955, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29055, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7734d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29052, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29052, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7734b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29052, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29052, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e772190", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29050, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29050, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7734a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29055, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29055, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7721b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29055, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29055, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vref_ds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e773590", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29074, - "line": 956, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29087, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e773560", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29081, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29087, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57000", - "kind": "EnumConstantDecl", - "name": "VREF_DS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7749d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29100, - "line": 957, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29141, - "line": 958, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e774920", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29104, - "line": 957, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29109, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e774908", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29106, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29106, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7748e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29106, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29106, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7735c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29104, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29104, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7748d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29109, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29109, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7735e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29109, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29109, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vout_cm\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7749c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29128, - "line": 958, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29141, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e774990", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29135, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29141, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57058", - "kind": "EnumConstantDecl", - "name": "VOUT_CM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e775e00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29154, - "line": 959, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29194, - "line": 960, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e775d50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29158, - "line": 959, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29163, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e775d38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29160, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29160, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e775d18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29160, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29160, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7749f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29158, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29158, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e775d00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29163, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 29163, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e774a10", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29163, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 29163, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vin_cm\"" - } - ] - } - ] - }, - { - "id": "0x564d8e775df0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29181, - "line": 960, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29194, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e775dc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29188, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29194, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd570b0", - "kind": "EnumConstantDecl", - "name": "VIN_CM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e777230", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29206, - "line": 961, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29249, - "line": 962, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e777180", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29210, - "line": 961, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29215, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e777168", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e777148", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29212, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29212, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e775e20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29210, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29210, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e777130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29215, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29215, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e775e40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29215, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29215, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vref_comp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e777220", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29236, - "line": 962, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29249, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7771f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29243, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29249, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57108", - "kind": "EnumConstantDecl", - "name": "VREF_COMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e778660", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29264, - "line": 963, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29305, - "line": 964, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7785b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29268, - "line": 963, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29273, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e778598", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29270, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29270, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e778578", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29270, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29270, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e777250", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29268, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29268, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e778560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29273, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29273, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e777270", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29273, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29273, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vb_comp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e778650", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29292, - "line": 964, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29305, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e778620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29299, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29305, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57160", - "kind": "EnumConstantDecl", - "name": "VB_COMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e779a90", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29318, - "line": 965, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29360, - "line": 966, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7799e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29322, - "line": 965, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29327, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7799c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29324, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29324, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7799a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29324, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29324, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e778680", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29322, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29322, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e779990", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29327, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29327, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7786a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29327, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29327, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vdd_prot\"" - } - ] - } - ] - }, - { - "id": "0x564d8e779a80", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29347, - "line": 966, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29360, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e779a50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29354, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29360, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd571b8", - "kind": "EnumConstantDecl", - "name": "VDD_PROT", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77aef0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29374, - "line": 967, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29415, - "line": 968, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e77ae40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29378, - "line": 967, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29383, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77ae28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77ae08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29380, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29380, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e779ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29378, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29378, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77adf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29383, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29383, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e779ad0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29383, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 29383, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"vin_com\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77aee0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29402, - "line": 968, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29415, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e77aeb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29409, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29415, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57210", - "kind": "EnumConstantDecl", - "name": "VIN_COM", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77c320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29428, - "line": 969, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29472, - "line": 970, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77c270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29432, - "line": 969, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29437, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77c258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29434, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29434, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77c238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29434, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29434, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77af10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29432, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29432, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77c220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29437, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29437, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77af30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29437, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29437, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vref_prech\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77c310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29459, - "line": 970, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29472, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77c2e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29466, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29472, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57268", - "kind": "EnumConstantDecl", - "name": "VREF_PRECH", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77d750", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29488, - "line": 971, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29531, - "line": 972, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e77d6a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29492, - "line": 971, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29497, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77d688", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29494, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29494, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77d668", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29494, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29494, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77c340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29492, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29492, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77d650", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29497, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29497, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77c360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29497, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 29497, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vb_pixbuf\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77d740", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29518, - "line": 972, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29531, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e77d710", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29525, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29531, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd572c0", - "kind": "EnumConstantDecl", - "name": "VB_PIXBUF", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77eb80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29546, - "line": 973, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29585, - "line": 974, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e77ead0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29550, - "line": 973, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29555, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77eab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29552, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29552, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77ea98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29552, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29552, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77d770", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29550, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29550, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77ea80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29555, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 29555, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77d790", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29555, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 29555, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vb_ds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77eb70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29572, - "line": 974, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29585, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e77eb40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29579, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29585, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57318", - "kind": "EnumConstantDecl", - "name": "VB_DS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e77ffb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29596, - "line": 975, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29640, - "line": 976, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77ff00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29600, - "line": 975, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29605, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e77fee8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29602, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29602, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e77fec8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29602, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29602, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77eba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29600, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29600, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e77feb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29605, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29605, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77ebc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29605, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29605, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vref_h_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e77ffa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29627, - "line": 976, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29640, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e77ff70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29634, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29640, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57370", - "kind": "EnumConstantDecl", - "name": "VREF_H_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7813e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29656, - "line": 977, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29700, - "line": 978, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e781330", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29660, - "line": 977, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29665, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e781318", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29662, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29662, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7812f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29662, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29662, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e77ffd0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29660, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29660, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7812e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29665, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29665, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e77fff0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29665, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29665, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vb_comp_fe\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7813d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29687, - "line": 978, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29700, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7813a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29694, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29700, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd573c8", - "kind": "EnumConstantDecl", - "name": "VB_COMP_FE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e782810", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29716, - "line": 979, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29761, - "line": 980, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e782760", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29720, - "line": 979, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29725, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e782748", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29722, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29722, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e782728", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29722, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29722, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e781400", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29720, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29720, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e782710", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29725, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29725, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e781420", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29725, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29725, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"vb_comp_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e782800", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29748, - "line": 980, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29761, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e7827d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29755, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29761, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57420", - "kind": "EnumConstantDecl", - "name": "VB_COMP_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e783c40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29778, - "line": 981, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29820, - "line": 982, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e783b90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29782, - "line": 981, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29787, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e783b78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29784, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29784, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e783b58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29784, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29784, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e782830", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29782, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29782, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e783b40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29787, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29787, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e782850", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29787, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 29787, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vcom_cds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e783c30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29807, - "line": 982, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29820, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e783c00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29814, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29820, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57478", - "kind": "EnumConstantDecl", - "name": "VCOM_CDS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e785070", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29834, - "line": 983, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29879, - "line": 984, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e784fc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29838, - "line": 983, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29843, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e784fa8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e784f88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e783c60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29838, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29838, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e784f70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29843, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29843, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e783c80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29843, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 29843, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"vref_rstore\"" - } - ] - } - ] - }, - { - "id": "0x564d8e785060", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29866, - "line": 984, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29879, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e785030", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29873, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29879, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd574d0", - "kind": "EnumConstantDecl", - "name": "VREF_RSTORE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7864a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29896, - "line": 985, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 29940, - "line": 986, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7863f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29900, - "line": 985, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29905, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7863d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29902, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29902, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7863b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29902, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29902, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e785090", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29900, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29900, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7863a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29905, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29905, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7850b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29905, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 29905, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vb_opa_1st\"" - } - ] - } - ] - }, - { - "id": "0x564d8e786490", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29927, - "line": 986, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 29940, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e786460", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29934, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 29940, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57528", - "kind": "EnumConstantDecl", - "name": "VB_OPA_1ST", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7878d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 29956, - "line": 987, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30002, - "line": 988, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e787820", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 29960, - "line": 987, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29965, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e787808", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29962, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29962, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7877e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29962, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 29962, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7864c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29960, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 29960, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7877d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 29965, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 29965, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7864e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 29965, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 29965, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"vref_comp_fe\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7878c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 29989, - "line": 988, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30002, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e787890", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 29996, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30002, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57580", - "kind": "EnumConstantDecl", - "name": "VREF_COMP_FE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e788d00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30020, - "line": 989, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30063, - "line": 990, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e788c50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30024, - "line": 989, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30029, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e788c38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e788c18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30026, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30026, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7878f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30024, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30024, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e788c00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30029, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30029, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e787910", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30029, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30029, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vcom_adc1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e788cf0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30050, - "line": 990, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30063, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e788cc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30057, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30063, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd575d8", - "kind": "EnumConstantDecl", - "name": "VCOM_ADC1", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78a130", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30078, - "line": 991, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30122, - "line": 992, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e78a080", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30082, - "line": 991, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30087, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78a068", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30084, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30084, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78a048", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30084, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30084, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e788d20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30082, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30082, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78a030", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30087, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30087, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e788d40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30087, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30087, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vref_l_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78a120", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30109, - "line": 992, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30122, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e78a0f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30116, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30122, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57630", - "kind": "EnumConstantDecl", - "name": "VREF_L_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78b560", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30138, - "line": 993, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30180, - "line": 994, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e78b4b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30142, - "line": 993, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30147, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78b498", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30144, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30144, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78b478", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30144, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30144, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78a150", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30142, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30142, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78b460", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30147, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 30147, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78a170", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30147, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 30147, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"vref_cds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78b550", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30167, - "line": 994, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30180, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e78b520", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30174, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30180, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57688", - "kind": "EnumConstantDecl", - "name": "VREF_CDS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78c990", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30194, - "line": 995, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30233, - "line": 996, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e78c8e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30198, - "line": 995, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30203, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78c8c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30200, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30200, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78c8a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30200, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30200, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78b580", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30198, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30198, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78c890", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30203, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30203, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78b5a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30203, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30203, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vb_cs\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78c980", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30220, - "line": 996, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30233, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e78c950", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30227, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30233, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd576e0", - "kind": "EnumConstantDecl", - "name": "VB_CS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78ddc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30244, - "line": 997, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30287, - "line": 998, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78dd10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30248, - "line": 997, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30253, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78dcf8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30250, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30250, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78dcd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30250, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30250, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78c9b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30248, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30248, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78dcc0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30253, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30253, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78c9d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30253, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30253, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vb_opa_fd\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78ddb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30274, - "line": 998, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30287, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78dd80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30281, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30287, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57738", - "kind": "EnumConstantDecl", - "name": "VB_OPA_FD", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e78f1f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30302, - "line": 999, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30345, - "line": 1000, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78f140", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30306, - "line": 999, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30311, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e78f128", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30308, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30308, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e78f108", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30308, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30308, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78dde0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30306, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30306, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e78f0f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30311, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30311, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78de00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30311, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30311, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vcom_adc2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e78f1e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30332, - "line": 1000, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30345, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e78f1b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30339, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30345, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57790", - "kind": "EnumConstantDecl", - "name": "VCOM_ADC2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e790620", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30360, - "line": 1001, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30400, - "line": 1002, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e790570", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30364, - "line": 1001, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30369, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e790558", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30366, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30366, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e790538", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30366, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30366, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e78f210", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30364, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30364, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e790520", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30369, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30369, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e78f230", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30369, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30369, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vcassh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e790610", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30387, - "line": 1002, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30400, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7905e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30394, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30400, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd577e8", - "kind": "EnumConstantDecl", - "name": "VCASSH", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e791a50", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30412, - "line": 1003, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30450, - "line": 1004, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7919a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30416, - "line": 1003, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30421, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e791988", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30418, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30418, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e791968", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30418, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30418, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e790640", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30416, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30416, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e791950", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30421, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30421, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e790660", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30421, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30421, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vth2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e791a40", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30437, - "line": 1004, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30450, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e791a10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30444, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30450, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57840", - "kind": "EnumConstantDecl", - "name": "VTH2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e792e80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30460, - "line": 1005, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30504, - "line": 1006, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e792dd0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30464, - "line": 1005, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30469, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e792db8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30466, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30466, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e792d98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30466, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30466, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e791a70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30464, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30464, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e792d80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30469, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30469, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e791a90", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30469, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30469, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vrshaper_n\"" - } - ] - } - ] - }, - { - "id": "0x564d8e792e70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30491, - "line": 1006, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30504, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e792e40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30498, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30504, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57898", - "kind": "EnumConstantDecl", - "name": "VRSHAPER_N", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7942b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30520, - "line": 1007, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30563, - "line": 1008, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e794200", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30524, - "line": 1007, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30529, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7941e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30526, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30526, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7941c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30526, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30526, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e792ea0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30524, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30524, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7941b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30529, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30529, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e792ec0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30529, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 30529, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vipre_out\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7942a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30550, - "line": 1008, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30563, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e794270", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30557, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30563, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd578f0", - "kind": "EnumConstantDecl", - "name": "VIPRE_OUT", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7956e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30578, - "line": 1009, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30616, - "line": 1010, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e795630", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30582, - "line": 1009, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e795618", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7955f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30584, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30584, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7942d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30582, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30582, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7955e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7942f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30587, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30587, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vth3\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7956d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30603, - "line": 1010, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30616, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7956a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30610, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30616, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57948", - "kind": "EnumConstantDecl", - "name": "VTH3", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e796b10", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30626, - "line": 1011, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30664, - "line": 1012, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e796a60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30630, - "line": 1011, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30635, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e796a48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e796a28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30632, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30632, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e795700", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30630, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30630, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e796a10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30635, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30635, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e795720", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30635, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30635, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vth1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e796b00", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30651, - "line": 1012, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30664, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e796ad0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30658, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30664, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd579a0", - "kind": "EnumConstantDecl", - "name": "VTH1", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e797f40", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30674, - "line": 1013, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30713, - "line": 1014, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e797e90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30678, - "line": 1013, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30683, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e797e78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30680, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30680, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e797e58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30680, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30680, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e796b30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30678, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30678, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e797e40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30683, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30683, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e796b50", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30683, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30683, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vicin\"" - } - ] - } - ] - }, - { - "id": "0x564d8e797f30", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30700, - "line": 1014, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30713, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e797f00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30707, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30713, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd579f8", - "kind": "EnumConstantDecl", - "name": "VICIN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e799370", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30724, - "line": 1015, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30762, - "line": 1016, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7992c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30728, - "line": 1015, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30733, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7992a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30730, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30730, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e799288", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30730, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30730, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e797f60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30728, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30728, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e799270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30733, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30733, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e797f80", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30733, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 30733, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"vcas\"" - } - ] - } - ] - }, - { - "id": "0x564d8e799360", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30749, - "line": 1016, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30762, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e799330", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30756, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30762, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57a50", - "kind": "EnumConstantDecl", - "name": "VCAS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79a7a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30772, - "line": 1017, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30812, - "line": 1018, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79a6f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30776, - "line": 1017, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30781, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79a6d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30778, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30778, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79a6b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30778, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30778, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e799390", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30776, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30776, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79a6a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30781, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30781, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7993b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30781, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30781, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vcal_n\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79a790", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30799, - "line": 1018, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30812, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79a760", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30806, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30812, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57aa8", - "kind": "EnumConstantDecl", - "name": "VCAL_N", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79bbf0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30824, - "line": 1019, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30863, - "line": 1020, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79bb40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30828, - "line": 1019, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30833, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79bb28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30830, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30830, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79bb08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30830, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30830, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79a7e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30828, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30828, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79baf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30833, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30833, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79a800", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30833, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30833, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vipre\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79bbe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30850, - "line": 1020, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30863, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79bbb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30857, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30863, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57b00", - "kind": "EnumConstantDecl", - "name": "VIPRE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79d020", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30874, - "line": 1021, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30914, - "line": 1022, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79cf70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30878, - "line": 1021, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30883, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79cf58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30880, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30880, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79cf38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30880, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30880, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79bc10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30878, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30878, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79cf20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30883, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30883, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79bc30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30883, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 30883, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vcal_p\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79d010", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30901, - "line": 1022, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30914, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e79cfe0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30908, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30914, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57b58", - "kind": "EnumConstantDecl", - "name": "VCAL_P", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79e450", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30926, - "line": 1023, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 30965, - "line": 1024, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79e3a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30930, - "line": 1023, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30935, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79e388", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30932, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30932, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79e368", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30932, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30932, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79d040", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30930, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30930, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79e350", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30935, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30935, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79d060", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30935, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 30935, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"vdcsh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79e440", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 30952, - "line": 1024, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 30965, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e79e410", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30959, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 30965, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57bb0", - "kind": "EnumConstantDecl", - "name": "VDCSH", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e79f880", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 30976, - "line": 1025, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31020, - "line": 1026, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e79f7d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 30980, - "line": 1025, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30985, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e79f7b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30982, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30982, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e79f798", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30982, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 30982, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79e470", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 30980, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 30980, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e79f780", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 30985, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30985, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79e490", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 30985, - "col": 14, - "tokLen": 12 - }, - "end": { - "offset": 30985, - "col": 14, - "tokLen": 12 - } - }, - "type": { - "qualType": "const char[11]" - }, - "valueCategory": "lvalue", - "value": "\"vbp_colbuf\"" - } - ] - } - ] - }, - { - "id": "0x564d8e79f870", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31007, - "line": 1026, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31020, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e79f840", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31014, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31020, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57c08", - "kind": "EnumConstantDecl", - "name": "VBP_COLBUF", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a0cb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31036, - "line": 1027, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31076, - "line": 1028, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7a0c00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31040, - "line": 1027, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31045, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a0be8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31042, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31042, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a0bc8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31042, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31042, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e79f8a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31040, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31040, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a0bb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31045, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 31045, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e79f8c0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31045, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 31045, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"vb_sda\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a0ca0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31063, - "line": 1028, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31076, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7a0c70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31070, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31076, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57c60", - "kind": "EnumConstantDecl", - "name": "VB_SDA", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a20e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31088, - "line": 1029, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31131, - "line": 1030, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a2030", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31092, - "line": 1029, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31097, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a2018", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31094, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31094, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a1ff8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31094, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31094, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a0cd0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31092, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31092, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a1fe0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31097, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31097, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a0cf0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31097, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31097, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vcasc_sfp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a20d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31118, - "line": 1030, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31131, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a20a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31125, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31131, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57cb8", - "kind": "EnumConstantDecl", - "name": "VCASC_SFP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a3510", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31146, - "line": 1031, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31189, - "line": 1032, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a3460", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31150, - "line": 1031, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31155, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a3448", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31152, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31152, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a3428", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31152, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31152, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a2100", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31150, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31150, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a3410", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31155, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31155, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a2120", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31155, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31155, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"vipre_cds\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a3500", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31176, - "line": 1032, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31189, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a34d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31183, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31189, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57d10", - "kind": "EnumConstantDecl", - "name": "VIPRE_CDS", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a4940", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31204, - "line": 1033, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31247, - "line": 1034, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a4890", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31208, - "line": 1033, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31213, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a4878", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31210, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31210, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a4858", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31210, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31210, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a3530", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31208, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31208, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a4840", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31213, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31213, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a3550", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31213, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31213, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"ibias_sfp\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a4930", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31234, - "line": 1034, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31247, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7a4900", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31241, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31247, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57d68", - "kind": "EnumConstantDecl", - "name": "IBIAS_SFP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a5d70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31262, - "line": 1035, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31304, - "line": 1036, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a5cc0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31266, - "line": 1035, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31271, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a5ca8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31268, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31268, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a5c88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31268, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31268, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a4960", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31266, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31266, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a5c70", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31271, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31271, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a4980", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31271, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31271, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"trimbits\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a5d60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31291, - "line": 1036, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31304, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a5d30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31298, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31304, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58188", - "kind": "EnumConstantDecl", - "name": "TRIMBIT_SCAN", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a71a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31322, - "line": 1037, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31367, - "line": 1038, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a70f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31326, - "line": 1037, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31331, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a70d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31328, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31328, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a70b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31328, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31328, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a5d90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31326, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31326, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a70a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31331, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31331, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a5db0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31331, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31331, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"highvoltage\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a7190", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31354, - "line": 1038, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31367, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7a7160", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31361, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31367, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57e18", - "kind": "EnumConstantDecl", - "name": "HIGH_VOLTAGE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a85d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31385, - "line": 1039, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31426, - "line": 1040, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7a8520", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31389, - "line": 1039, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31394, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a8508", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31391, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31391, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a84e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31391, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31391, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a71c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31389, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31389, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a84d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31394, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 31394, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a71e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31394, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 31394, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"iodelay\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a85c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31413, - "line": 1040, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31426, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7a8590", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31420, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31426, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd56fa8", - "kind": "EnumConstantDecl", - "name": "IO_DELAY", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7a9a00", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31440, - "line": 1041, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31482, - "line": 1042, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7a9950", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31444, - "line": 1041, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31449, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7a9938", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31446, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31446, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a9918", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31446, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31446, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a85f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31444, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31444, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7a9900", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31449, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31449, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a8610", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31449, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 31449, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"temp_adc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7a99f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31469, - "line": 1042, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31482, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7a99c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31476, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31482, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57e70", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_ADC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7aae30", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31503, - "line": 1043, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31546, - "line": 1044, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aad80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31507, - "line": 1043, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31512, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7aad68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31509, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31509, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aad48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31509, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31509, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7a9a20", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31507, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31507, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7aad30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31512, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31512, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7a9a40", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31512, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31512, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpga\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7aae20", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31533, - "line": 1044, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31546, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aadf0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31540, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31546, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57ec8", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGA", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ac260", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31568, - "line": 1045, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31614, - "line": 1046, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7ac1b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31572, - "line": 1045, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31577, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ac198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31574, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31574, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ac178", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31574, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31574, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7aae50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31572, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31572, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ac160", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31577, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 31577, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aae70", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31577, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 31577, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpgaext\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ac250", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31601, - "line": 1046, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31614, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7ac220", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31608, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31614, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57f20", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGAEXT", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ad690", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31639, - "line": 1047, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31682, - "line": 1048, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7ad5e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31643, - "line": 1047, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31648, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ad5c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31645, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31645, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ad5a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31645, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31645, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ac280", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31643, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31643, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ad590", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31648, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31648, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ac2a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31648, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31648, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_10ge\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ad680", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31669, - "line": 1048, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31682, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7ad650", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31676, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31682, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57f78", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_10GE", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7aeac0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31704, - "line": 1049, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31747, - "line": 1050, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aea10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31708, - "line": 1049, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31713, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ae9f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31710, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31710, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ae9d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31710, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31710, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ad6b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31708, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31708, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ae9c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31713, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31713, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ad6d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31713, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31713, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_dcdc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7aeab0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31734, - "line": 1050, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31747, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7aea80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31741, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31747, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd57fd0", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_DCDC", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7afef0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31769, - "line": 1051, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31812, - "line": 1052, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7afe40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31773, - "line": 1051, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31778, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7afe28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7afe08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31775, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31775, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7aeae0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31773, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31773, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7afdf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31778, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31778, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aeb00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31778, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31778, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_sodl\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7afee0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31799, - "line": 1052, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31812, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7afeb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31806, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31812, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58028", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_SODL", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b1320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31834, - "line": 1053, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31877, - "line": 1054, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7b1270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31838, - "line": 1053, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31843, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b1258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b1238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31840, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31840, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7aff10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31838, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31838, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b1220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31843, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31843, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7aff30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31843, - "col": 14, - "tokLen": 11 - }, - "end": { - "offset": 31843, - "col": 14, - "tokLen": 11 - } - }, - "type": { - "qualType": "const char[10]" - }, - "valueCategory": "lvalue", - "value": "\"temp_sodr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b1310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31864, - "line": 1054, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31877, - "col": 22, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7b12e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31871, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31877, - "col": 22, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58080", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_SODR", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b2750", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31899, - "line": 1055, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 31944, - "line": 1056, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b26a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31903, - "line": 1055, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31908, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b2688", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31905, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31905, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b2668", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31905, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31905, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b1340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31903, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31903, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b2650", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31908, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31908, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b1360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31908, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31908, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpgafl\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b2740", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31931, - "line": 1056, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 31944, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b2710", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31938, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 31944, - "col": 22, - "tokLen": 17 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd580d8", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGA2", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b3b80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 31967, - "line": 1057, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32012, - "line": 1058, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b3ad0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 31971, - "line": 1057, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31976, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b3ab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31973, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31973, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b3a98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31973, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 31973, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b2770", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 31971, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 31971, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b3a80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 31976, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31976, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b2790", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 31976, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 31976, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"temp_fpgafr\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b3b70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 31999, - "line": 1058, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32012, - "col": 22, - "tokLen": 17 - } - }, - "inner": [ - { - "id": "0x564d8e7b3b40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32006, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32012, - "col": 22, - "tokLen": 17 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58130", - "kind": "EnumConstantDecl", - "name": "TEMPERATURE_FPGA3", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b4fb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32035, - "line": 1059, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32081, - "line": 1060, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7b4f00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32039, - "line": 1059, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32044, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b4ee8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32041, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32041, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b4ec8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32041, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32041, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b3ba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32039, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32039, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b4eb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32044, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 32044, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b3bc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32044, - "col": 14, - "tokLen": 14 - }, - "end": { - "offset": 32044, - "col": 14, - "tokLen": 14 - } - }, - "type": { - "qualType": "const char[13]" - }, - "valueCategory": "lvalue", - "value": "\"temp_slowadc\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b4fa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32068, - "line": 1060, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32081, - "col": 22, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7b4f70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32075, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32081, - "col": 22, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::dacIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd584e0", - "kind": "EnumConstantDecl", - "name": "SLOW_ADC_TEMP", - "type": { - "qualType": "slsDetectorDefs::dacIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b55d8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 32100, - "line": 1061, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7b55c0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 32100, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7b5598", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 32106, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7b5578", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32106, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7b5570", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7b5540", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 32106, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32143, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7b5528", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7b5510", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7b54f0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7b54e8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7b54b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b5498", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32140, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 32140, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b5478", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32140, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 32140, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7b5460", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32119, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b4fe0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32119, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 32119, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char[19]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown dac Index \"" - } - ] - }, - { - "id": "0x564d8e7b5010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32142, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 32142, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e72f980", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7b5a50", - "kind": "FunctionDecl", - "loc": { - "offset": 32178, - "file": "ToString.cpp", - "line": 1064, - "col": 30, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 32149, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 32583, - "line": 1078, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a8fe0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs10powerIndexEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::powerIndex (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "inner": [ - { - "id": "0x564d8dd585f0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "decl": { - "id": "0x564d8dd58550", - "kind": "EnumDecl", - "name": "powerIndex" - } - } - ] - }, - { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "loc": { - "offset": 32206, - "line": 1064, - "col": 58, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 32187, - "col": 39, - "tokLen": 5 - }, - "end": { - "offset": 32206, - "col": 58, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7bdb90", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 32209, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 32583, - "line": 1078, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7b7040", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32215, - "line": 1065, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32252, - "line": 1066, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b6f90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32219, - "line": 1065, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32224, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b6f78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32221, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32221, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b6f58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32221, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32221, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b5c38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32219, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32219, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b6f40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32224, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32224, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b5c58", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32224, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32224, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_a\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b7030", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32239, - "line": 1066, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32252, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b7000", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32246, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32252, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58610", - "kind": "EnumConstantDecl", - "name": "V_POWER_A", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b8470", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32267, - "line": 1067, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32304, - "line": 1068, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b83c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32271, - "line": 1067, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32276, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b83a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32273, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32273, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b8388", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32273, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32273, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b7060", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32271, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32271, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b8370", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32276, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32276, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b7080", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32276, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32276, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_b\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b8460", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32291, - "line": 1068, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32304, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b8430", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32298, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32304, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58668", - "kind": "EnumConstantDecl", - "name": "V_POWER_B", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7b98a0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32319, - "line": 1069, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32356, - "line": 1070, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b97f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32323, - "line": 1069, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32328, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7b97d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32325, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32325, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b97b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32325, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32325, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b8490", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32323, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32323, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7b97a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32328, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32328, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b84b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32328, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32328, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_c\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7b9890", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32343, - "line": 1070, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32356, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7b9860", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32350, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32356, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd586c0", - "kind": "EnumConstantDecl", - "name": "V_POWER_C", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bacf0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32371, - "line": 1071, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32408, - "line": 1072, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7bac40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32375, - "line": 1071, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32380, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bac28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32377, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32377, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bac08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32377, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32377, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7b98c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32375, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32375, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7babf0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32380, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32380, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7b98e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32380, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 32380, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"v_d\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bace0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32395, - "line": 1072, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32408, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7bacb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32402, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32408, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58718", - "kind": "EnumConstantDecl", - "name": "V_POWER_D", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bc120", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32423, - "line": 1073, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32461, - "line": 1074, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7bc070", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32427, - "line": 1073, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32432, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bc058", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32429, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32429, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bc038", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32429, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32429, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bad10", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32427, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32427, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7bc020", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32432, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 32432, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bad30", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32432, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 32432, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"v_io\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bc110", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32448, - "line": 1074, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32461, - "col": 22, - "tokLen": 10 - } - }, - "inner": [ - { - "id": "0x564d8e7bc0e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32455, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32461, - "col": 22, - "tokLen": 10 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd58770", - "kind": "EnumConstantDecl", - "name": "V_POWER_IO", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bd550", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32477, - "line": 1075, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32517, - "line": 1076, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7bd4a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32481, - "line": 1075, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32486, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bd488", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bd468", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32483, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32483, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bc140", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32481, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32481, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7bd450", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32486, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 32486, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bc160", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32486, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 32486, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"v_chip\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bd540", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32504, - "line": 1076, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32517, - "col": 22, - "tokLen": 12 - } - }, - "inner": [ - { - "id": "0x564d8e7bd510", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32511, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32517, - "col": 22, - "tokLen": 12 - } - }, - "type": { - "qualType": "slsDetectorDefs::powerIndex" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd587c8", - "kind": "EnumConstantDecl", - "name": "V_POWER_CHIP", - "type": { - "qualType": "slsDetectorDefs::powerIndex" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7bdb78", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 32535, - "line": 1077, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7bdb60", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 32535, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7bdb38", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 32541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7bdb18", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7bdb10", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7bdae0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 32541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32580, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7bdac8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7bdab0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7bda90", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7bda88", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7bda50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bda38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32577, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 32577, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bda18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32577, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 32577, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7bda00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32554, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bd580", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32554, - "col": 24, - "tokLen": 22 - }, - "end": { - "offset": 32554, - "col": 24, - "tokLen": 22 - } - }, - "type": { - "qualType": "const char[21]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown power Index \"" - } - ] - }, - { - "id": "0x564d8e7bd5b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32579, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 32579, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7b5978", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7bdd60", - "kind": "FunctionDecl", - "loc": { - "offset": 32614, - "file": "ToString.cpp", - "line": 1080, - "col": 29, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 32586, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 32974, - "line": 1090, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a9570", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs9burstModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::burstMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "inner": [ - { - "id": "0x564d8dd59b10", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "decl": { - "id": "0x564d8dd59a68", - "kind": "EnumDecl", - "name": "burstMode" - } - } - ] - }, - { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "loc": { - "offset": 32642, - "line": 1080, - "col": 57, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 32623, - "col": 38, - "tokLen": 5 - }, - "end": { - "offset": 32642, - "col": 57, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7c3630", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 32645, - "col": 60, - "tokLen": 1 - }, - "end": { - "offset": 32974, - "line": 1090, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7bf360", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32651, - "line": 1081, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32699, - "line": 1082, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7bf2b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32655, - "line": 1081, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32660, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7bf298", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32657, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32657, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bf278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32657, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32657, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bdf48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32655, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32655, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7bf260", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32660, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32660, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bdf68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32660, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32660, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"burst_internal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7bf350", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32686, - "line": 1082, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32699, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7bf320", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32693, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32699, - "col": 22, - "tokLen": 14 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59b30", - "kind": "EnumConstantDecl", - "name": "BURST_INTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c0790", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32719, - "line": 1083, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32767, - "line": 1084, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7c06e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32723, - "line": 1083, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32728, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c06c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32725, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32725, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c06a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32725, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32725, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7bf380", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32723, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32723, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c0690", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32728, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32728, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7bf3a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32728, - "col": 14, - "tokLen": 16 - }, - "end": { - "offset": 32728, - "col": 14, - "tokLen": 16 - } - }, - "type": { - "qualType": "const char[15]" - }, - "valueCategory": "lvalue", - "value": "\"burst_external\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c0780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32754, - "line": 1084, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32767, - "col": 22, - "tokLen": 14 - } - }, - "inner": [ - { - "id": "0x564d8e7c0750", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32761, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32767, - "col": 22, - "tokLen": 14 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59b88", - "kind": "EnumConstantDecl", - "name": "BURST_EXTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c1bc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32787, - "line": 1085, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32832, - "line": 1086, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c1b10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32791, - "line": 1085, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32796, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c1af8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32793, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32793, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c1ad8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32793, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32793, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c07b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32791, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32791, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c1ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32796, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32796, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c07d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32796, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32796, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"cw_internal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c1bb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32819, - "line": 1086, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32832, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c1b80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32826, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32832, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59be0", - "kind": "EnumConstantDecl", - "name": "CONTINUOUS_INTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c2ff0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 32857, - "line": 1087, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 32902, - "line": 1088, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c2f40", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32861, - "line": 1087, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32866, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c2f28", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32863, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32863, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c2f08", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32863, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 32863, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c1be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32861, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 32861, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c2ef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32866, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32866, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c1c00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32866, - "col": 14, - "tokLen": 13 - }, - "end": { - "offset": 32866, - "col": 14, - "tokLen": 13 - } - }, - "type": { - "qualType": "const char[12]" - }, - "valueCategory": "lvalue", - "value": "\"cw_external\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c2fe0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 32889, - "line": 1088, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 32902, - "col": 22, - "tokLen": 19 - } - }, - "inner": [ - { - "id": "0x564d8e7c2fb0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32896, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 32902, - "col": 22, - "tokLen": 19 - } - }, - "type": { - "qualType": "slsDetectorDefs::burstMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59c38", - "kind": "EnumConstantDecl", - "name": "CONTINUOUS_EXTERNAL", - "type": { - "qualType": "slsDetectorDefs::burstMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c3618", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 32927, - "line": 1089, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7c3600", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 32927, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7c35d8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 32933, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7c35b8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32933, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c35b0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c3580", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 32933, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 32971, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7c3568", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7c3550", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7c3530", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c3528", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c34f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c34d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32968, - "col": 46, - "tokLen": 1 - }, - "end": { - "offset": 32968, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c34b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32968, - "col": 46, - "tokLen": 1 - }, - "end": { - "offset": 32968, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7c34a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32946, - "col": 24, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c3020", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 32946, - "col": 24, - "tokLen": 21 - }, - "end": { - "offset": 32946, - "col": 24, - "tokLen": 21 - } - }, - "type": { - "qualType": "const char[20]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown burst mode \"" - } - ] - }, - { - "id": "0x564d8e7c3050", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 32970, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 32970, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7bdc88", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7c37f0", - "kind": "FunctionDecl", - "loc": { - "offset": 33012, - "file": "ToString.cpp", - "line": 1092, - "col": 36, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 32977, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 33230, - "line": 1098, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3a9b60", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs16timingSourceTypeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingSourceType (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "inner": [ - { - "id": "0x564d8dd59dc0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "decl": { - "id": "0x564d8dd59d18", - "kind": "EnumDecl", - "name": "timingSourceType" - } - } - ] - }, - { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "loc": { - "offset": 33040, - "line": 1092, - "col": 64, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 33021, - "col": 45, - "tokLen": 5 - }, - "end": { - "offset": 33040, - "col": 64, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7c6890", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 33043, - "col": 67, - "tokLen": 1 - }, - "end": { - "offset": 33230, - "line": 1098, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7c4de0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33049, - "line": 1093, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33091, - "line": 1094, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c4d30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33053, - "line": 1093, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33058, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c4d18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33055, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33055, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c4cf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33055, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33055, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c39d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33053, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33053, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c4ce0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33058, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33058, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c39f8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33058, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33058, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"internal\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c4dd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33078, - "line": 1094, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33091, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c4da0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33085, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33091, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59de0", - "kind": "EnumConstantDecl", - "name": "TIMING_INTERNAL", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c6210", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33112, - "line": 1095, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33154, - "line": 1096, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c6160", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33116, - "line": 1095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33121, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c6148", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6128", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33118, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33118, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c4e00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33116, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33116, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c6110", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33121, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33121, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c4e20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33121, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33121, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"external\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c6200", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33141, - "line": 1096, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33154, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7c61d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33148, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33154, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59e38", - "kind": "EnumConstantDecl", - "name": "TIMING_EXTERNAL", - "type": { - "qualType": "slsDetectorDefs::timingSourceType" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c6878", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 33175, - "line": 1097, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7c6860", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 33175, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7c6838", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 33181, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7c6818", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33181, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c6810", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c67e0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 33181, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33227, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7c67c8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7c67b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7c6790", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7c6788", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7c6750", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c6738", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33224, - "col": 54, - "tokLen": 1 - }, - "end": { - "offset": 33224, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6718", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33224, - "col": 54, - "tokLen": 1 - }, - "end": { - "offset": 33224, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7c6700", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33194, - "col": 24, - "tokLen": 29 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6240", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33194, - "col": 24, - "tokLen": 29 - }, - "end": { - "offset": 33194, - "col": 24, - "tokLen": 29 - } - }, - "type": { - "qualType": "const char[28]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown timing source type \"" - } - ] - }, - { - "id": "0x564d8e7c6278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33226, - "col": 56, - "tokLen": 1 - }, - "end": { - "offset": 33226, - "col": 56, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c3718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7c6a40", - "kind": "FunctionDecl", - "loc": { - "offset": 33263, - "file": "ToString.cpp", - "line": 1100, - "col": 31, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 33233, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 33673, - "line": 1114, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aa0f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs11M3_GainCapsEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::M3_GainCaps (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "inner": [ - { - "id": "0x564d8dd59f30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "decl": { - "id": "0x564d8dd59e90", - "kind": "EnumDecl", - "name": "M3_GainCaps" - } - } - ] - }, - { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "loc": { - "offset": 33291, - "line": 1100, - "col": 59, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 33272, - "col": 40, - "tokLen": 5 - }, - "end": { - "offset": 33291, - "col": 59, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7ceb60", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 33294, - "col": 62, - "tokLen": 1 - }, - "end": { - "offset": 33673, - "line": 1114, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7c8030", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33300, - "line": 1101, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33340, - "line": 1102, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7c7f80", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33304, - "line": 1101, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33309, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c7f68", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33306, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33306, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c7f48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33306, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33306, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c6c28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33304, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33304, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c7f30", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33309, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33309, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c6c48", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33309, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33309, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"C10pre\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c8020", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33327, - "line": 1102, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33340, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7c7ff0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33334, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33340, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd59fd0", - "kind": "EnumConstantDecl", - "name": "M3_C10pre", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7c9460", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33355, - "line": 1103, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33394, - "line": 1104, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7c93b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33359, - "line": 1103, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33364, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7c9398", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33361, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33361, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c9378", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33361, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33361, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c8050", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33359, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33359, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7c9360", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33364, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33364, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c8070", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33364, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33364, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"C15sh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7c9450", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33381, - "line": 1104, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33394, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7c9420", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33388, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33394, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a0a8", - "kind": "EnumConstantDecl", - "name": "M3_C15sh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ca890", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33408, - "line": 1105, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33447, - "line": 1106, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ca7e0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33412, - "line": 1105, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33417, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ca7c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33414, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33414, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ca7a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33414, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33414, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7c9480", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33412, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33412, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ca790", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33417, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33417, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7c94a0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33417, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33417, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"C30sh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ca880", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33434, - "line": 1106, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33447, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ca850", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33441, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33447, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a180", - "kind": "EnumConstantDecl", - "name": "M3_C30sh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7cbcc0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33461, - "line": 1107, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33500, - "line": 1108, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7cbc10", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33465, - "line": 1107, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33470, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7cbbf8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33467, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33467, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cbbd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33467, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33467, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ca8b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33465, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33465, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7cbbc0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33470, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33470, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ca8d0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33470, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33470, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"C50sh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7cbcb0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33487, - "line": 1108, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33500, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7cbc80", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33494, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33500, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a258", - "kind": "EnumConstantDecl", - "name": "M3_C50sh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7cd0f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33514, - "line": 1109, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33556, - "line": 1110, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e7cd040", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33518, - "line": 1109, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33523, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7cd028", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33520, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33520, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cd008", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33520, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33520, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7cbce0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33518, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33518, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ccff0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33523, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33523, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cbd00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33523, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 33523, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"C225ACsh\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7cd0e0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33543, - "line": 1110, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33556, - "col": 22, - "tokLen": 11 - } - }, - "inner": [ - { - "id": "0x564d8e7cd0b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33550, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33556, - "col": 22, - "tokLen": 11 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a330", - "kind": "EnumConstantDecl", - "name": "M3_C225ACsh", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ce520", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33573, - "line": 1111, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33613, - "line": 1112, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7ce470", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33577, - "line": 1111, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33582, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ce458", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33579, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33579, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ce438", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33579, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33579, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7cd110", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33577, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33577, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ce420", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33582, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33582, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cd130", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33582, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33582, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"C15pre\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ce510", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33600, - "line": 1112, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33613, - "col": 22, - "tokLen": 9 - } - }, - "inner": [ - { - "id": "0x564d8e7ce4e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33607, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33613, - "col": 22, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a408", - "kind": "EnumConstantDecl", - "name": "M3_C15pre", - "type": { - "qualType": "slsDetectorDefs::M3_GainCaps" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ceb48", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 33628, - "line": 1113, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ceb30", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 33628, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ceb08", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 33634, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7ceae8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33634, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ceae0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ceab0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 33634, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33670, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7cea98", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7cea80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7cea60", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7cea58", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7cea20", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7cea08", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33667, - "col": 44, - "tokLen": 1 - }, - "end": { - "offset": 33667, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ce9e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33667, - "col": 44, - "tokLen": 1 - }, - "end": { - "offset": 33667, - "col": 44, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7ce9d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33647, - "col": 24, - "tokLen": 19 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ce550", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33647, - "col": 24, - "tokLen": 19 - }, - "end": { - "offset": 33647, - "col": 24, - "tokLen": 19 - } - }, - "type": { - "qualType": "const char[18]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown gain cap \"" - } - ] - }, - { - "id": "0x564d8e7ce580", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33669, - "col": 46, - "tokLen": 1 - }, - "end": { - "offset": 33669, - "col": 46, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7c6968", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7ced30", - "kind": "FunctionDecl", - "loc": { - "offset": 33707, - "file": "ToString.cpp", - "line": 1116, - "col": 32, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 33676, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 33990, - "line": 1126, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aa680", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs12portPositionEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::portPosition (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "inner": [ - { - "id": "0x564d8dd5a590", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "decl": { - "id": "0x564d8dd5a4f0", - "kind": "EnumDecl", - "name": "portPosition" - } - } - ] - }, - { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "loc": { - "offset": 33735, - "line": 1116, - "col": 60, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 33716, - "col": 41, - "tokLen": 5 - }, - "end": { - "offset": 33735, - "col": 60, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7d45f0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 33738, - "col": 63, - "tokLen": 1 - }, - "end": { - "offset": 33990, - "line": 1126, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d0320", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33744, - "line": 1117, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33782, - "line": 1118, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d0270", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33748, - "line": 1117, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33753, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d0258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33750, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33750, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d0238", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33750, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33750, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7cef18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33748, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33748, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d0220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33753, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 33753, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7cef38", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33753, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 33753, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"left\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d0310", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33769, - "line": 1118, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33782, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d02e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33776, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33782, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a5b0", - "kind": "EnumConstantDecl", - "name": "LEFT", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d1750", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33792, - "line": 1119, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33831, - "line": 1120, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7d16a0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33796, - "line": 1119, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33801, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d1688", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33798, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33798, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d1668", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33798, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33798, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d0340", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33796, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33796, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d1650", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33801, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33801, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d0360", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33801, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 33801, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"right\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d1740", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33818, - "line": 1120, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33831, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7d1710", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33825, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33831, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a608", - "kind": "EnumConstantDecl", - "name": "RIGHT", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d2b80", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33842, - "line": 1121, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33879, - "line": 1122, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e7d2ad0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33846, - "line": 1121, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33851, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d2ab8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33848, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33848, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d2a98", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33848, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33848, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d1770", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33846, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33846, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d2a80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33851, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 33851, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d1790", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33851, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 33851, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"top\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d2b70", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33866, - "line": 1122, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33879, - "col": 22, - "tokLen": 3 - } - }, - "inner": [ - { - "id": "0x564d8e7d2b40", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33873, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33879, - "col": 22, - "tokLen": 3 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a660", - "kind": "EnumConstantDecl", - "name": "TOP", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d3fb0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 33888, - "line": 1123, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 33928, - "line": 1124, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7d3f00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33892, - "line": 1123, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33897, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d3ee8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33894, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33894, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d3ec8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33894, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 33894, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d2ba0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33892, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 33892, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7d3eb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33897, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33897, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d2bc0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33897, - "col": 14, - "tokLen": 8 - }, - "end": { - "offset": 33897, - "col": 14, - "tokLen": 8 - } - }, - "type": { - "qualType": "const char[7]" - }, - "valueCategory": "lvalue", - "value": "\"bottom\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d3fa0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 33915, - "line": 1124, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 33928, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7d3f70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33922, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 33928, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::portPosition" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a6b8", - "kind": "EnumConstantDecl", - "name": "BOTTOM", - "type": { - "qualType": "slsDetectorDefs::portPosition" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d45d8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 33940, - "line": 1125, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7d45c0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 33940, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d4598", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 33946, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7d4578", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33946, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7d4570", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7d4540", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 33946, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 33987, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7d4528", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7d4510", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d44f0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7d44e8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7d44b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d4498", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33984, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 33984, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d4478", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33984, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 33984, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7d4460", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33959, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d3fe0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 33959, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 33959, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown port position \"" - } - ] - }, - { - "id": "0x564d8e7d4010", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 33986, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 33986, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7cec58", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7d47b0", - "kind": "FunctionDecl", - "loc": { - "offset": 34030, - "file": "ToString.cpp", - "line": 1128, - "col": 38, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 33993, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 34453, - "line": 1139, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aac10", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs18streamingInterfaceEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::streamingInterface (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "inner": [ - { - "id": "0x564d8dd5a950", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "decl": { - "id": "0x564d8dd5a8b0", - "kind": "EnumDecl", - "name": "streamingInterface" - } - } - ] - }, - { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "loc": { - "offset": 34058, - "line": 1128, - "col": 66, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 34039, - "col": 47, - "tokLen": 5 - }, - "end": { - "offset": 34058, - "col": 66, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7da3f0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 34061, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 34453, - "line": 1139, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d4a98", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 34067, - "line": 1129, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 34085, - "col": 23, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "loc": { - "offset": 34079, - "col": 17, - "tokLen": 2 - }, - "range": { - "begin": { - "offset": 34067, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 34084, - "col": 22, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7d4a68", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 34084, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 34084, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const basic_string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7d4a48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34084, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 34084, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d6050", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34091, - "line": 1130, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34158, - "line": 1131, - "col": 30, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7d5578", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 34095, - "line": 1130, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34123, - "col": 37, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7d5400", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 34095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34105, - "col": 19, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d53d0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 34095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34097, - "col": 11, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6fb8", - "inner": [ - { - "id": "0x564d8e7d4ab0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34095, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34095, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7d4b48", - "kind": "CharacterLiteral", - "range": { - "begin": { - "offset": 34102, - "col": 16, - "tokLen": 3 - }, - "end": { - "offset": 34102, - "col": 16, - "tokLen": 3 - } - }, - "type": { - "qualType": "char" - }, - "valueCategory": "prvalue", - "value": 44 - }, - { - "id": "0x564d8e7d5448", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d5430", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 102107, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2991, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a00b0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d5560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34110, - "file": "ToString.cpp", - "line": 1130, - "col": 24, - "tokLen": 3 - }, - "end": { - "offset": 34123, - "col": 37, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7d5530", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34110, - "col": 24, - "tokLen": 3 - }, - "end": { - "offset": 34123, - "col": 37, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7d5fa8", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 34137, - "line": 1131, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34158, - "col": 30, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string" - }, - "valueCategory": "lvalue", - "inner": [ - { - "id": "0x564d8e7d5f78", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 34137, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34140, - "col": 12, - "tokLen": 5 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "erase", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6ac4e8", - "inner": [ - { - "id": "0x564d8e7d5598", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34137, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34137, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d5ef8", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34157, - "col": 29, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d5eb0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34149, - "col": 21, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6fb8", - "inner": [ - { - "id": "0x564d8e7d5ee0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34146, - "col": 18, - "tokLen": 2 - } - }, - "type": { - "qualType": "const std::basic_string" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d5620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34146, - "col": 18, - "tokLen": 2 - }, - "end": { - "offset": 34146, - "col": 18, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d56b8", - "kind": "CharacterLiteral", - "range": { - "begin": { - "offset": 34154, - "col": 26, - "tokLen": 3 - }, - "end": { - "offset": 34154, - "col": 26, - "tokLen": 3 - } - }, - "type": { - "qualType": "char" - }, - "valueCategory": "prvalue", - "value": 44 - }, - { - "id": "0x564d8e7d5f28", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d5430", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 102107, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2991, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a00b0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 102107, - "col": 42, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d6030", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7d6018", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 76670, - "line": 2323, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 76670, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7d5ff8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 76670, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 76670, - "col": 50, - "tokLen": 4, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7d74b0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34165, - "file": "ToString.cpp", - "line": 1132, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34224, - "line": 1133, - "col": 42, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d73e8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34169, - "line": 1132, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34175, - "col": 15, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d73d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34172, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34172, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d73b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34172, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34172, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d7380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34169, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34169, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d6070", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34169, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34169, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d7398", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34175, - "col": 15, - "tokLen": 6 - }, - "end": { - "offset": 34175, - "col": 15, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d6090", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34175, - "col": 15, - "tokLen": 6 - }, - "end": { - "offset": 34175, - "col": 15, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"none\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d74a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34191, - "line": 1133, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34224, - "col": 42, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7d7470", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34198, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34224, - "col": 42, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5a9b0", - "kind": "EnumConstantDecl", - "name": "NONE", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d8910", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34234, - "line": 1134, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34292, - "line": 1135, - "col": 42, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7d8848", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34238, - "line": 1134, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34244, - "col": 15, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d8830", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34241, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34241, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d8810", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34241, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34241, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d87e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34238, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34238, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d74d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34238, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34238, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d87f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34244, - "col": 15, - "tokLen": 5 - }, - "end": { - "offset": 34244, - "col": 15, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d74f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34244, - "col": 15, - "tokLen": 5 - }, - "end": { - "offset": 34244, - "col": 15, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"lll\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d8900", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34259, - "line": 1135, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34292, - "col": 42, - "tokLen": 16 - } - }, - "inner": [ - { - "id": "0x564d8e7d88d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34266, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34292, - "col": 42, - "tokLen": 16 - } - }, - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5aa88", - "kind": "EnumConstantDecl", - "name": "LOW_LATENCY_LINK", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7d9d70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34314, - "line": 1136, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34374, - "line": 1137, - "col": 42, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7d9ca8", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34318, - "line": 1136, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34324, - "col": 15, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7d9c90", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34321, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34321, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d9c70", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34321, - "col": 12, - "tokLen": 2 - }, - "end": { - "offset": 34321, - "col": 12, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7d9c40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34318, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34318, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7d8930", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34318, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 34318, - "col": 9, - "tokLen": 2 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d49e0", - "kind": "VarDecl", - "name": "rs", - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - } - } - } - ] - }, - { - "id": "0x564d8e7d9c58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34324, - "col": 15, - "tokLen": 7 - }, - "end": { - "offset": 34324, - "col": 15, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d8950", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34324, - "col": 15, - "tokLen": 7 - }, - "end": { - "offset": 34324, - "col": 15, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"10gbe\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7d9d60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34341, - "line": 1137, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34374, - "col": 42, - "tokLen": 13 - } - }, - "inner": [ - { - "id": "0x564d8e7d9d30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34348, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34374, - "col": 42, - "tokLen": 13 - } - }, - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5ab60", - "kind": "EnumConstantDecl", - "name": "ETHERNET_10GB", - "type": { - "qualType": "slsDetectorDefs::streamingInterface" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7da3d8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 34393, - "line": 1138, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7da3c0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 34393, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7da398", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 34399, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7da378", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34399, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7da370", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7da340", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 34399, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34450, - "col": 62, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7da328", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7da310", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7da2f0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7da2e8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7da2b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7da298", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34447, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 34447, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7da278", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34447, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 34447, - "col": 59, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7da260", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34412, - "col": 24, - "tokLen": 34 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7d9da0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34412, - "col": 24, - "tokLen": 34 - }, - "end": { - "offset": 34412, - "col": 24, - "tokLen": 34 - } - }, - "type": { - "qualType": "const char[33]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown streamingInterface type \"" - } - ] - }, - { - "id": "0x564d8e7d9dd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34449, - "col": 61, - "tokLen": 1 - }, - "end": { - "offset": 34449, - "col": 61, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7d46d8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7da5c0", - "kind": "FunctionDecl", - "loc": { - "offset": 34488, - "file": "ToString.cpp", - "line": 1141, - "col": 33, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 34456, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 34678, - "line": 1147, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ab1a0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs13vetoAlgorithmEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::vetoAlgorithm (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "inner": [ - { - "id": "0x564d8dd5ad30", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "decl": { - "id": "0x564d8dd5ac90", - "kind": "EnumDecl", - "name": "vetoAlgorithm" - } - } - ] - }, - { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "loc": { - "offset": 34516, - "line": 1141, - "col": 61, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 34497, - "col": 42, - "tokLen": 5 - }, - "end": { - "offset": 34516, - "col": 61, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7dd640", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 34519, - "col": 64, - "tokLen": 1 - }, - "end": { - "offset": 34678, - "line": 1147, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7dbbd0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34525, - "line": 1142, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34563, - "line": 1143, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7dbb20", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34529, - "line": 1142, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34534, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7dbb08", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34531, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34531, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dbae8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34531, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34531, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7da7a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34529, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34529, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7dbad0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34534, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 34534, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7da7c8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34534, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 34534, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"hits\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7dbbc0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34550, - "line": 1143, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34563, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7dbb90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34557, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34563, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5ad50", - "kind": "EnumConstantDecl", - "name": "ALG_HITS", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7dd000", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34577, - "line": 1144, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34614, - "line": 1145, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7dcf50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34581, - "line": 1144, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34586, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7dcf38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34583, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34583, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dcf18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34583, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34583, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7dbbf0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34581, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34581, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7dcf00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34586, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 34586, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dbc10", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34586, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 34586, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"raw\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7dcff0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34601, - "line": 1145, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34614, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7dcfc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34608, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34614, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5ada8", - "kind": "EnumConstantDecl", - "name": "ALG_RAW", - "type": { - "qualType": "slsDetectorDefs::vetoAlgorithm" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7dd628", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 34627, - "line": 1146, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7dd610", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 34627, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7dd5e8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 34633, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7dd5c8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34633, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7dd5c0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7dd590", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 34633, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 34675, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7dd578", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7dd560", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7dd540", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7dd538", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7dd500", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7dd4e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34672, - "col": 50, - "tokLen": 1 - }, - "end": { - "offset": 34672, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dd4c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34672, - "col": 50, - "tokLen": 1 - }, - "end": { - "offset": 34672, - "col": 50, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7dd4b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34646, - "col": 24, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dd030", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34646, - "col": 24, - "tokLen": 25 - }, - "end": { - "offset": 34646, - "col": 24, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char[24]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown veto algorithm \"" - } - ] - }, - { - "id": "0x564d8e7dd060", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34674, - "col": 52, - "tokLen": 1 - }, - "end": { - "offset": 34674, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7da4e0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7dd7f0", - "kind": "FunctionDecl", - "loc": { - "offset": 34708, - "file": "ToString.cpp", - "line": 1149, - "col": 28, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 34681, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35134, - "line": 1163, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ab730", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8gainModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::gainMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "inner": [ - { - "id": "0x564d8dd5aea0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "decl": { - "id": "0x564d8dd5ae00", - "kind": "EnumDecl", - "name": "gainMode" - } - } - ] - }, - { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "loc": { - "offset": 34736, - "line": 1149, - "col": 56, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 34717, - "col": 37, - "tokLen": 5 - }, - "end": { - "offset": 34736, - "col": 56, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7e5910", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 34739, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 35134, - "line": 1163, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7dede0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34745, - "line": 1150, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34786, - "line": 1151, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7ded30", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34749, - "line": 1150, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34754, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ded18", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34751, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34751, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7decf8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34751, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34751, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7dd9d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34749, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34749, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7dece0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34754, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 34754, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dd9f8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34754, - "col": 14, - "tokLen": 9 - }, - "end": { - "offset": 34754, - "col": 14, - "tokLen": 9 - } - }, - "type": { - "qualType": "const char[8]" - }, - "valueCategory": "lvalue", - "value": "\"dynamic\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7dedd0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34773, - "line": 1151, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34786, - "col": 22, - "tokLen": 7 - } - }, - "inner": [ - { - "id": "0x564d8e7deda0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34780, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34786, - "col": 22, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5aec0", - "kind": "EnumConstantDecl", - "name": "DYNAMIC", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e0210", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34799, - "line": 1152, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34846, - "line": 1153, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e0160", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34803, - "line": 1152, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34808, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e0148", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34805, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34805, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e0128", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34805, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34805, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7dee00", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34803, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34803, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e0110", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34808, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34808, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7dee20", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34808, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34808, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"forceswitchg1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e0200", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34833, - "line": 1153, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34846, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e01d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34840, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34846, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5af18", - "kind": "EnumConstantDecl", - "name": "FORCE_SWITCH_G1", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e1640", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34867, - "line": 1154, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34914, - "line": 1155, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e1590", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34871, - "line": 1154, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34876, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e1578", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34873, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34873, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e1558", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34873, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34873, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e0230", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34871, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34871, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e1540", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34876, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34876, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e0250", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34876, - "col": 14, - "tokLen": 15 - }, - "end": { - "offset": 34876, - "col": 14, - "tokLen": 15 - } - }, - "type": { - "qualType": "const char[14]" - }, - "valueCategory": "lvalue", - "value": "\"forceswitchg2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e1630", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34901, - "line": 1155, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34914, - "col": 22, - "tokLen": 15 - } - }, - "inner": [ - { - "id": "0x564d8e7e1600", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34908, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34914, - "col": 22, - "tokLen": 15 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5af70", - "kind": "EnumConstantDecl", - "name": "FORCE_SWITCH_G2", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e2a70", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34935, - "line": 1156, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 34974, - "line": 1157, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e29c0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34939, - "line": 1156, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34944, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e29a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34941, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34941, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e2988", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34941, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34941, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e1660", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34939, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34939, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e2970", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34944, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34944, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e1680", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34944, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34944, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"fixg1\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e2a60", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 34961, - "line": 1157, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 34974, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e2a30", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34968, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 34974, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5afc8", - "kind": "EnumConstantDecl", - "name": "FIX_G1", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e3ea0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 34986, - "line": 1158, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35025, - "line": 1159, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e3df0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 34990, - "line": 1158, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34995, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e3dd8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e3db8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34992, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 34992, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e2a90", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 34990, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 34990, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e3da0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 34995, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34995, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e2ab0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 34995, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 34995, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"fixg2\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e3e90", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35012, - "line": 1159, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35025, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e3e60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35019, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35025, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b020", - "kind": "EnumConstantDecl", - "name": "FIX_G2", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e52d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35037, - "line": 1160, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35076, - "line": 1161, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e5220", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35041, - "line": 1160, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35046, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e5208", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35043, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35043, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e51e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35043, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35043, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e3ec0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35041, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35041, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e51d0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35046, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35046, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e3ee0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35046, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35046, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"fixg0\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e52c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35063, - "line": 1161, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35076, - "col": 22, - "tokLen": 6 - } - }, - "inner": [ - { - "id": "0x564d8e7e5290", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35070, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35076, - "col": 22, - "tokLen": 6 - } - }, - "type": { - "qualType": "slsDetectorDefs::gainMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b078", - "kind": "EnumConstantDecl", - "name": "FIX_G0", - "type": { - "qualType": "slsDetectorDefs::gainMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e58f8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35088, - "line": 1162, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7e58e0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35088, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7e58b8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35094, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7e5898", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35094, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e5890", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e5860", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35094, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35131, - "col": 48, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7e5848", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7e5830", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7e5810", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e5808", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e57d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e57b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35128, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 35128, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e5798", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35128, - "col": 45, - "tokLen": 1 - }, - "end": { - "offset": 35128, - "col": 45, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7e5780", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35107, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e5300", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35107, - "col": 24, - "tokLen": 20 - }, - "end": { - "offset": 35107, - "col": 24, - "tokLen": 20 - } - }, - "type": { - "qualType": "const char[19]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown gain mode \"" - } - ] - }, - { - "id": "0x564d8e7e5330", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35130, - "col": 47, - "tokLen": 1 - }, - "end": { - "offset": 35130, - "col": 47, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7dd718", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7e5ae0", - "kind": "FunctionDecl", - "loc": { - "offset": 35164, - "file": "ToString.cpp", - "line": 1165, - "col": 28, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35137, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35353, - "line": 1171, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3abcc0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs8polarityEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::polarity (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "inner": [ - { - "id": "0x564d8dd5b170", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "decl": { - "id": "0x564d8dd5b0d0", - "kind": "EnumDecl", - "name": "polarity" - } - } - ] - }, - { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "loc": { - "offset": 35192, - "line": 1165, - "col": 56, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35173, - "col": 37, - "tokLen": 5 - }, - "end": { - "offset": 35192, - "col": 56, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7e8b40", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35195, - "col": 59, - "tokLen": 1 - }, - "end": { - "offset": 35353, - "line": 1171, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7e70d0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35201, - "line": 1166, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35238, - "line": 1167, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e7020", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35205, - "line": 1166, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35210, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e7008", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35207, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35207, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e6fe8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35207, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35207, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e5cc8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35205, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35205, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e6fd0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35210, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35210, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e5ce8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35210, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35210, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"pos\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e70c0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35225, - "line": 1167, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35238, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e7090", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35232, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35238, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b190", - "kind": "EnumConstantDecl", - "name": "POSITIVE", - "type": { - "qualType": "slsDetectorDefs::polarity" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e8500", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35252, - "line": 1168, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35289, - "line": 1169, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e8450", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35256, - "line": 1168, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35261, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e8438", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35258, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35258, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e8418", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35258, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35258, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e70f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35256, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35256, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7e8400", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35261, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35261, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e7110", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35261, - "col": 14, - "tokLen": 5 - }, - "end": { - "offset": 35261, - "col": 14, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"neg\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7e84f0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35276, - "line": 1169, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35289, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7e84c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35283, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35289, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::polarity" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b1e8", - "kind": "EnumConstantDecl", - "name": "NEGATIVE", - "type": { - "qualType": "slsDetectorDefs::polarity" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7e8b28", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35303, - "line": 1170, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7e8b10", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35303, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7e8ae8", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35309, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7e8ac8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35309, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e8ac0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e8a90", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35309, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35350, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7e8a78", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7e8a60", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7e8a40", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7e8a38", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7e8a00", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7e89e8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35347, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 35347, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e89c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35347, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 35347, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7e89b0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35322, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e8530", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35322, - "col": 24, - "tokLen": 24 - }, - "end": { - "offset": 35322, - "col": 24, - "tokLen": 24 - } - }, - "type": { - "qualType": "const char[23]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown polarity mode \"" - } - ] - }, - { - "id": "0x564d8e7e8560", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35349, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 35349, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e5a08", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7e8cf0", - "kind": "FunctionDecl", - "loc": { - "offset": 35392, - "file": "ToString.cpp", - "line": 1173, - "col": 37, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35356, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35591, - "line": 1179, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ac250", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs17timingInfoDecoderEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::timingInfoDecoder (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "inner": [ - { - "id": "0x564d8dd5b2e0", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "decl": { - "id": "0x564d8dd5b240", - "kind": "EnumDecl", - "name": "timingInfoDecoder" - } - } - ] - }, - { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "loc": { - "offset": 35420, - "line": 1173, - "col": 65, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35401, - "col": 46, - "tokLen": 5 - }, - "end": { - "offset": 35420, - "col": 65, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7ebd90", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35423, - "col": 68, - "tokLen": 1 - }, - "end": { - "offset": 35591, - "line": 1179, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ea2e0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35429, - "line": 1174, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35471, - "line": 1175, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ea230", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35433, - "line": 1174, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35438, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ea218", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35435, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35435, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ea1f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35435, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35435, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7e8ed8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35433, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35433, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ea1e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35438, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35438, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7e8ef8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35438, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35438, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"swissfel\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ea2d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35458, - "line": 1175, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35471, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ea2a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35465, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35471, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b300", - "kind": "EnumConstantDecl", - "name": "SWISSFEL", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7eb710", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35485, - "line": 1176, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35524, - "line": 1177, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7eb660", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35489, - "line": 1176, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35494, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7eb648", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35491, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35491, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7eb628", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35491, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35491, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ea300", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35489, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35489, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7eb610", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35494, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35494, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ea320", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35494, - "col": 14, - "tokLen": 7 - }, - "end": { - "offset": 35494, - "col": 14, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"shine\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7eb700", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35511, - "line": 1177, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35524, - "col": 22, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7eb6d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35518, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35524, - "col": 22, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b358", - "kind": "EnumConstantDecl", - "name": "SHINE", - "type": { - "qualType": "slsDetectorDefs::timingInfoDecoder" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ebd78", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35535, - "line": 1178, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ebd60", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35535, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ebd38", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7ebd18", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ebd10", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ebce0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35541, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35588, - "col": 58, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7ebcc8", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7ebcb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7ebc90", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ebc88", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ebc50", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ebc38", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35585, - "col": 55, - "tokLen": 1 - }, - "end": { - "offset": 35585, - "col": 55, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ebc18", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35585, - "col": 55, - "tokLen": 1 - }, - "end": { - "offset": 35585, - "col": 55, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7ebc00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35554, - "col": 24, - "tokLen": 30 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7eb740", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35554, - "col": 24, - "tokLen": 30 - }, - "end": { - "offset": 35554, - "col": 24, - "tokLen": 30 - } - }, - "type": { - "qualType": "const char[29]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown Timing Info Decoder \"" - } - ] - }, - { - "id": "0x564d8e7eb778", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35587, - "col": 57, - "tokLen": 1 - }, - "end": { - "offset": 35587, - "col": 57, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7e8c18", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7ebf40", - "kind": "FunctionDecl", - "loc": { - "offset": 35627, - "file": "ToString.cpp", - "line": 1181, - "col": 34, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35594, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 35820, - "line": 1187, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ac7e0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIN15slsDetectorDefs14collectionModeEEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "defs::collectionMode (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "inner": [ - { - "id": "0x564d8dd5b450", - "kind": "EnumType", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "decl": { - "id": "0x564d8dd5b3b0", - "kind": "EnumDecl", - "name": "collectionMode" - } - } - ] - }, - { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "loc": { - "offset": 35655, - "line": 1181, - "col": 62, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35636, - "col": 43, - "tokLen": 5 - }, - "end": { - "offset": 35655, - "col": 62, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7eefd0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35658, - "col": 65, - "tokLen": 1 - }, - "end": { - "offset": 35820, - "line": 1187, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ed530", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35664, - "line": 1182, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35702, - "line": 1183, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ed480", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35668, - "line": 1182, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35673, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ed468", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35670, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35670, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ed448", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35670, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35670, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ec128", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35668, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35668, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ed430", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35673, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 35673, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ec148", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35673, - "col": 14, - "tokLen": 6 - }, - "end": { - "offset": 35673, - "col": 14, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"hole\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ed520", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35689, - "line": 1183, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35702, - "col": 22, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ed4f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35696, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35702, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b470", - "kind": "EnumConstantDecl", - "name": "HOLE", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ee960", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35712, - "line": 1184, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 35754, - "line": 1185, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ee8b0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35716, - "line": 1184, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35721, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7ee898", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35718, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35718, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ee878", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35718, - "col": 11, - "tokLen": 2 - }, - "end": { - "offset": 35718, - "col": 11, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7ed550", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35716, - "col": 9, - "tokLen": 1 - }, - "end": { - "offset": 35716, - "col": 9, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ee860", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35721, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35721, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ed570", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35721, - "col": 14, - "tokLen": 10 - }, - "end": { - "offset": 35721, - "col": 14, - "tokLen": 10 - } - }, - "type": { - "qualType": "const char[9]" - }, - "valueCategory": "lvalue", - "value": "\"electron\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7ee950", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 35741, - "line": 1185, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 35754, - "col": 22, - "tokLen": 8 - } - }, - "inner": [ - { - "id": "0x564d8e7ee920", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35748, - "col": 16, - "tokLen": 4 - }, - "end": { - "offset": 35754, - "col": 22, - "tokLen": 8 - } - }, - "type": { - "qualType": "slsDetectorDefs::collectionMode" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dd5b4c8", - "kind": "EnumConstantDecl", - "name": "ELECTRON", - "type": { - "qualType": "slsDetectorDefs::collectionMode" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7eefb8", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 35768, - "line": 1186, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7eefa0", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 35768, - "col": 5, - "tokLen": 5 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7eef78", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 35774, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7eef58", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35774, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7eef50", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7eef20", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 35774, - "col": 11, - "tokLen": 12 - }, - "end": { - "offset": 35817, - "col": 54, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7eef08", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7eeef0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7eeed0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7eeec8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7eee90", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7eee78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35814, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 35814, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7eee58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35814, - "col": 51, - "tokLen": 1 - }, - "end": { - "offset": 35814, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7eee40", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35787, - "col": 24, - "tokLen": 26 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ee990", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35787, - "col": 24, - "tokLen": 26 - }, - "end": { - "offset": 35787, - "col": 24, - "tokLen": 26 - } - }, - "type": { - "qualType": "const char[25]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown collection mode \"" - } - ] - }, - { - "id": "0x564d8e7ee9c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35816, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 35816, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ebe68", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7ef130", - "kind": "FunctionDecl", - "loc": { - "offset": 35843, - "file": "ToString.cpp", - "line": 1189, - "col": 21, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 35823, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 36272, - "line": 1198, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ad740", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIhEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint8_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned char" - }, - "inner": [ - { - "id": "0x564d8c93dc50", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned char" - } - } - ] - }, - { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "loc": { - "offset": 35871, - "line": 1189, - "col": 49, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 35852, - "col": 30, - "tokLen": 5 - }, - "end": { - "offset": 35871, - "col": 49, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f4130", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 35874, - "col": 52, - "tokLen": 1 - }, - "end": { - "offset": 36272, - "line": 1198, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f2e20", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 35880, - "line": 1190, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35934, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ef300", - "kind": "VarDecl", - "loc": { - "offset": 35884, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 35880, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35932, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f2df0", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35932, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2d90", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35920, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f2c50", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35902, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c20", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35893, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7ef368", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35891, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 35891, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f2c80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35898, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 35898, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ef400", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 35898, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 35898, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f2cb0", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f2d78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35907, - "file": "ToString.cpp", - "line": 1190, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 35920, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f2d48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35907, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 35920, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f2db0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 35927, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 35927, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f2dd0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 35932, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 35932, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f3090", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 35940, - "line": 1191, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35979, - "col": 44, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "loc": { - "offset": 35944, - "col": 9, - "tokLen": 5 - }, - "range": { - "begin": { - "offset": 35940, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 35978, - "col": 43, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "value", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f3028", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 35952, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 35978, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f3010", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35952, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 35957, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f2f78", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35952, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 35957, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f2f28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35962, - "col": 27, - "tokLen": 1 - }, - "end": { - "offset": 35962, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f3060", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35965, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 35965, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f2f48", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 35965, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 35965, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f3078", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35974, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 35974, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f2f58", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35974, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 35974, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef300", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4070", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 35985, - "line": 1192, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 36230, - "line": 1196, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f3450", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 35989, - "line": 1192, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36086, - "line": 1193, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7f3288", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 35989, - "line": 1192, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36031, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "<", - "inner": [ - { - "id": "0x564d8e7f3258", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35989, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 35989, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f30a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35989, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 35989, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f3270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36031, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f3238", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36031, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned char" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f3220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36027, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f31f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 35997, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36027, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cad2760", - "kind": "CXXMethodDecl", - "name": "min", - "type": { - "qualType": "unsigned char () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f3430", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36044, - "line": 1193, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36086, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": ">", - "inner": [ - { - "id": "0x564d8e7f3400", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36044, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36044, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f32a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36044, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36044, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f3418", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36086, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f33e0", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36086, - "col": 51, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned char" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f33c8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36082, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f3398", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36052, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36082, - "col": 47, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned char () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cad2838", - "kind": "CXXMethodDecl", - "name": "max", - "type": { - "qualType": "unsigned char () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4058", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36089, - "col": 54, - "tokLen": 1 - }, - "end": { - "offset": 36230, - "line": 1196, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4040", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 36099, - "line": 1194, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7f4028", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 36099, - "line": 1194, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f4000", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 36105, - "line": 1194, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7f3fe0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36105, - "line": 1194, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f3fd8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f3fa8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 36105, - "line": 1194, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36223, - "line": 1195, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7f3f90", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7f3f78", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f3f58", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f3f50", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f3f18", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36118, - "line": 1194, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f3f00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36158, - "line": 1194, - "col": 68, - "tokLen": 1 - }, - "end": { - "offset": 36158, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(basic_string, allocator> &&, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f3ee0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36158, - "col": 68, - "tokLen": 1 - }, - "end": { - "offset": 36158, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dda7ec0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7f3eb0", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "xvalue", - "storageDuration": "full expression", - "inner": [ - { - "id": "0x564d8e7f3a30", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f3a28", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f39f0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f39d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36154, - "col": 64, - "tokLen": 1 - }, - "end": { - "offset": 36154, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f39b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36154, - "col": 64, - "tokLen": 1 - }, - "end": { - "offset": 36154, - "col": 64, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7f39a0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36118, - "col": 28, - "tokLen": 35 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f34e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36118, - "col": 28, - "tokLen": 35 - }, - "end": { - "offset": 36118, - "col": 28, - "tokLen": 35 - } - }, - "type": { - "qualType": "const char[34]" - }, - "valueCategory": "lvalue", - "value": "\"Cannot scan uint8_t from string '\"" - } - ] - }, - { - "id": "0x564d8e7f3520", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36156, - "col": 66, - "tokLen": 1 - }, - "end": { - "offset": 36156, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ef068", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f3ec8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36187, - "line": 1195, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36187, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f3a50", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36187, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36187, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char[35]" - }, - "valueCategory": "lvalue", - "value": "\"'. Value must be in range 0 - 255.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4120", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 36236, - "line": 1197, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 36269, - "col": 38, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f40f0", - "kind": "CXXStaticCastExpr", - "range": { - "begin": { - "offset": 36243, - "col": 12, - "tokLen": 11 - }, - "end": { - "offset": 36269, - "col": 38, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned char", - "qualType": "uint8_t", - "typeAliasDeclId": "0x564d8cb58398" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f40d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36264, - "col": 33, - "tokLen": 5 - }, - "end": { - "offset": 36264, - "col": 33, - "tokLen": 5 - } - }, - "type": { - "desugaredQualType": "unsigned char", - "qualType": "uint8_t", - "typeAliasDeclId": "0x564d8cb58398" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f40c0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36264, - "col": 33, - "tokLen": 5 - }, - "end": { - "offset": 36264, - "col": 33, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f4090", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36264, - "col": 33, - "tokLen": 5 - }, - "end": { - "offset": 36264, - "col": 33, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f2e50", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7f42a0", - "kind": "FunctionDecl", - "loc": { - "offset": 36296, - "file": "ToString.cpp", - "line": 1200, - "col": 22, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 36275, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 36731, - "line": 1209, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3adc50", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToItEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint16_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned short" - }, - "inner": [ - { - "id": "0x564d8c93dc70", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned short" - } - } - ] - }, - { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "loc": { - "offset": 36324, - "line": 1200, - "col": 50, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 36305, - "col": 31, - "tokLen": 5 - }, - "end": { - "offset": 36324, - "col": 50, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f61b0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36327, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 36731, - "line": 1209, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4fa8", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36333, - "line": 1201, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36387, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4470", - "kind": "VarDecl", - "loc": { - "offset": 36337, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 36333, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36385, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f4f78", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36385, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f4f18", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36373, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f4df0", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36355, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f4dc0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36346, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f44d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36344, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36344, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f4e20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36351, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36351, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f4570", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36351, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36351, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f4e38", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f4f00", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36360, - "file": "ToString.cpp", - "line": 1201, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36373, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f4ed0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36360, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36373, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f4f38", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36380, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 36380, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f4f58", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36385, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 36385, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f51b0", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36393, - "line": 1202, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36432, - "col": 44, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "loc": { - "offset": 36397, - "col": 9, - "tokLen": 5 - }, - "range": { - "begin": { - "offset": 36393, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36431, - "col": 43, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "value", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f5148", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36405, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36431, - "col": 43, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f5130", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36405, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36410, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5100", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36405, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36410, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f50b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36415, - "col": 27, - "tokLen": 1 - }, - "end": { - "offset": 36415, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f5180", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36418, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 36418, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f50d0", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 36418, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 36418, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f5198", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36427, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 36427, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f50e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36427, - "col": 39, - "tokLen": 4 - }, - "end": { - "offset": 36427, - "col": 39, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4470", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f60f0", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 36438, - "line": 1203, - "col": 5, - "tokLen": 2 - }, - "end": { - "offset": 36688, - "line": 1207, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f5560", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36442, - "line": 1203, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36541, - "line": 1204, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "||", - "inner": [ - { - "id": "0x564d8e7f5398", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36442, - "line": 1203, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36485, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "<", - "inner": [ - { - "id": "0x564d8e7f5368", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36442, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36442, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f51c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36442, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36442, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f5380", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36485, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f5348", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36485, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned short" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f5330", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36481, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5300", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36450, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36481, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cbf64e0", - "kind": "CXXMethodDecl", - "name": "min", - "type": { - "qualType": "unsigned short () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f5540", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36498, - "line": 1204, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36541, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": ">", - "inner": [ - { - "id": "0x564d8e7f5510", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36498, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36498, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f53b8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36498, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36498, - "col": 9, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7f5528", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36541, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f54f0", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36541, - "col": 52, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned short" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f54d8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36537, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short (*)() noexcept" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f54a8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36506, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 36537, - "col": 48, - "tokLen": 3 - } - }, - "type": { - "qualType": "unsigned short () noexcept" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8cbf65b8", - "kind": "CXXMethodDecl", - "name": "max", - "type": { - "qualType": "unsigned short () noexcept" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f60d8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36544, - "col": 55, - "tokLen": 1 - }, - "end": { - "offset": 36688, - "line": 1207, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f60c0", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 36554, - "line": 1205, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7f60a8", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 36554, - "line": 1205, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f6080", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 36560, - "line": 1205, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916d20", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const std::string &)" - } - }, - "inner": [ - { - "id": "0x564d8e7f6060", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36560, - "line": 1205, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f6058", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f6028", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 36560, - "line": 1205, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 36681, - "line": 1206, - "col": 66, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const std::string &)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7f6010", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "lvalue", - "storageDuration": "full expression", - "boundToLValueRef": true, - "inner": [ - { - "id": "0x564d8e7f5ff8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const basic_string, allocator>" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f5fd8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f5fd0", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f5f98", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36573, - "line": 1205, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f5f80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36614, - "line": 1205, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 36614, - "col": 69, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(basic_string, allocator> &&, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5f60", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36614, - "col": 69, - "tokLen": 1 - }, - "end": { - "offset": 36614, - "col": 69, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dda7ec0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (basic_string, allocator> &&, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7f5f30", - "kind": "MaterializeTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "xvalue", - "storageDuration": "full expression", - "inner": [ - { - "id": "0x564d8e7f5ab0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7f5aa8", - "dtor": { - "id": "0x564d8d69a348", - "kind": "CXXDestructorDecl", - "name": "~basic_string", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7f5a70", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "std::basic_string", - "qualType": "basic_string, allocator>" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7f5a58", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36610, - "col": 65, - "tokLen": 1 - }, - "end": { - "offset": 36610, - "col": 65, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (*)(const char *, const basic_string, allocator> &)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5a38", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36610, - "col": 65, - "tokLen": 1 - }, - "end": { - "offset": 36610, - "col": 65, - "tokLen": 1 - } - }, - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8dd928c0", - "kind": "FunctionDecl", - "name": "operator+", - "type": { - "qualType": "basic_string, allocator> (const char *, const basic_string, allocator> &)" - } - } - } - ] - }, - { - "id": "0x564d8e7f5a20", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36573, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5590", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36573, - "col": 28, - "tokLen": 36 - }, - "end": { - "offset": 36573, - "col": 28, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char[35]" - }, - "valueCategory": "lvalue", - "value": "\"Cannot scan uint16_t from string '\"" - } - ] - }, - { - "id": "0x564d8e7f55d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36612, - "col": 67, - "tokLen": 1 - }, - "end": { - "offset": 36612, - "col": 67, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f41d0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f5f48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36643, - "line": 1206, - "col": 28, - "tokLen": 38 - }, - "end": { - "offset": 36643, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f5ad0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36643, - "col": 28, - "tokLen": 38 - }, - "end": { - "offset": 36643, - "col": 28, - "tokLen": 38 - } - }, - "type": { - "qualType": "const char[37]" - }, - "valueCategory": "lvalue", - "value": "\"'. Value must be in range 0 - 65535.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f61a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 36694, - "line": 1208, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 36728, - "col": 39, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f6170", - "kind": "CXXStaticCastExpr", - "range": { - "begin": { - "offset": 36701, - "col": 12, - "tokLen": 11 - }, - "end": { - "offset": 36728, - "col": 39, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned short", - "qualType": "uint16_t", - "typeAliasDeclId": "0x564d8cb58400" - }, - "valueCategory": "prvalue", - "castKind": "NoOp", - "inner": [ - { - "id": "0x564d8e7f6158", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36723, - "col": 34, - "tokLen": 5 - }, - "end": { - "offset": 36723, - "col": 34, - "tokLen": 5 - } - }, - "type": { - "desugaredQualType": "unsigned short", - "qualType": "uint16_t", - "typeAliasDeclId": "0x564d8cb58400" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f6140", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36723, - "col": 34, - "tokLen": 5 - }, - "end": { - "offset": 36723, - "col": 34, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "isPartOfExplicitCast": true, - "inner": [ - { - "id": "0x564d8e7f6110", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36723, - "col": 34, - "tokLen": 5 - }, - "end": { - "offset": 36723, - "col": 34, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f4fd8", - "kind": "VarDecl", - "name": "value", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7f6320", - "kind": "FunctionDecl", - "loc": { - "offset": 36755, - "file": "ToString.cpp", - "line": 1211, - "col": 22, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 36734, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 36889, - "line": 1214, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ae160", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIjEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint32_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned int" - }, - "inner": [ - { - "id": "0x564d8c93dc90", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned int" - } - } - ] - }, - { - "id": "0x564d8e7f6250", - "kind": "ParmVarDecl", - "loc": { - "offset": 36783, - "line": 1211, - "col": 50, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 36764, - "col": 31, - "tokLen": 5 - }, - "end": { - "offset": 36783, - "col": 50, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f7238", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36786, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 36889, - "line": 1214, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f7028", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36792, - "line": 1212, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36846, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f64f0", - "kind": "VarDecl", - "loc": { - "offset": 36796, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 36792, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 36844, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f6ff8", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36844, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f6f98", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36832, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f6e70", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36814, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f6e40", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36805, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f6558", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36803, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36803, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f6250", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f6ea0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36810, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36810, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f65f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36810, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36810, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f6eb8", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f6f80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36819, - "file": "ToString.cpp", - "line": 1212, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36832, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f6f50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36819, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36832, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f6fb8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36839, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 36839, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f6fd8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36844, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 36844, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f7228", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 36852, - "line": 1213, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 36886, - "col": 39, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f7210", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36886, - "col": 39, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned int", - "qualType": "uint32_t", - "typeAliasDeclId": "0x564d8cb58468" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f71a8", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36886, - "col": 39, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned long" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f7190", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36864, - "col": 17, - "tokLen": 5 - } - }, - "type": { - "qualType": "unsigned long (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f7100", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36859, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 36864, - "col": 17, - "tokLen": 5 - } - }, - "type": { - "qualType": "unsigned long (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6c7648", - "kind": "FunctionDecl", - "name": "stoul", - "type": { - "qualType": "unsigned long (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f70b0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36870, - "col": 23, - "tokLen": 1 - }, - "end": { - "offset": 36870, - "col": 23, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f6250", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f71e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36873, - "col": 26, - "tokLen": 7 - }, - "end": { - "offset": 36873, - "col": 26, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f70d0", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 36873, - "col": 26, - "tokLen": 7 - }, - "end": { - "offset": 36873, - "col": 26, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f71f8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36882, - "col": 35, - "tokLen": 4 - }, - "end": { - "offset": 36882, - "col": 35, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f70e0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36882, - "col": 35, - "tokLen": 4 - }, - "end": { - "offset": 36882, - "col": 35, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f64f0", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7f7390", - "kind": "FunctionDecl", - "loc": { - "offset": 36913, - "file": "ToString.cpp", - "line": 1216, - "col": 22, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 36892, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 37048, - "line": 1219, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3ae630", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToImEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "uint64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "unsigned long" - }, - "inner": [ - { - "id": "0x564d8c93dcb0", - "kind": "BuiltinType", - "type": { - "qualType": "unsigned long" - } - } - ] - }, - { - "id": "0x564d8e7f72c8", - "kind": "ParmVarDecl", - "loc": { - "offset": 36941, - "line": 1216, - "col": 50, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 36922, - "col": 31, - "tokLen": 5 - }, - "end": { - "offset": 36941, - "col": 50, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f82a8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 36944, - "col": 53, - "tokLen": 1 - }, - "end": { - "offset": 37048, - "line": 1219, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f8098", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 36950, - "line": 1217, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37004, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f7560", - "kind": "VarDecl", - "loc": { - "offset": 36954, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 36950, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37002, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f8068", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37002, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f8008", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36990, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f7ee0", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36972, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f7eb0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36963, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f75c8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36961, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 36961, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f72c8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f7f10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36968, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36968, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f7660", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 36968, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 36968, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f7f28", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f7ff0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 36977, - "file": "ToString.cpp", - "line": 1217, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36990, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f7fc0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 36977, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 36990, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f8028", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 36997, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 36997, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f8048", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37002, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 37002, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f8298", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37010, - "line": 1218, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 37045, - "col": 40, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f8280", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37045, - "col": 40, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "uint64_t", - "typeAliasDeclId": "0x564d8cb584d0" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f8218", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37045, - "col": 40, - "tokLen": 1 - } - }, - "type": { - "qualType": "unsigned long long" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f8200", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37022, - "col": 17, - "tokLen": 6 - } - }, - "type": { - "qualType": "unsigned long long (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f8170", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37017, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37022, - "col": 17, - "tokLen": 6 - } - }, - "type": { - "qualType": "unsigned long long (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6c97c8", - "kind": "FunctionDecl", - "name": "stoull", - "type": { - "qualType": "unsigned long long (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f8120", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37029, - "col": 24, - "tokLen": 1 - }, - "end": { - "offset": 37029, - "col": 24, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f72c8", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f8250", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37032, - "col": 27, - "tokLen": 7 - }, - "end": { - "offset": 37032, - "col": 27, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f8140", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 37032, - "col": 27, - "tokLen": 7 - }, - "end": { - "offset": 37032, - "col": 27, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f8268", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37041, - "col": 36, - "tokLen": 4 - }, - "end": { - "offset": 37041, - "col": 36, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f8150", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37041, - "col": 36, - "tokLen": 4 - }, - "end": { - "offset": 37041, - "col": 36, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f7560", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7f8408", - "kind": "FunctionDecl", - "loc": { - "offset": 37067, - "file": "ToString.cpp", - "line": 1221, - "col": 17, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 37051, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 37200, - "line": 1224, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3aeb48", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIiEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "int" - }, - "inner": [ - { - "id": "0x564d8c93dbf0", - "kind": "BuiltinType", - "type": { - "qualType": "int" - } - } - ] - }, - { - "id": "0x564d8e7f8338", - "kind": "ParmVarDecl", - "loc": { - "offset": 37095, - "line": 1221, - "col": 45, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37076, - "col": 26, - "tokLen": 5 - }, - "end": { - "offset": 37095, - "col": 45, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f92b0", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37098, - "col": 48, - "tokLen": 1 - }, - "end": { - "offset": 37200, - "line": 1224, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9118", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 37104, - "line": 1222, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37158, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f85e0", - "kind": "VarDecl", - "loc": { - "offset": 37108, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 37104, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 37156, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7f90e8", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37156, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f9088", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37144, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e7f8f60", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37126, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f8f30", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37117, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7f8648", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37115, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 37115, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f8338", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e7f8f90", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37122, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 37122, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f86e0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37122, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 37122, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e7f8fa8", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f9070", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37131, - "file": "ToString.cpp", - "line": 1222, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 37144, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f9040", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37131, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 37144, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e7f90a8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37151, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 37151, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e7f90c8", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37156, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 37156, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7f92a0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37164, - "line": 1223, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 37197, - "col": 38, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9238", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37171, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37197, - "col": 38, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f9220", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37171, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37176, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f91f0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37171, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 37176, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7f91a0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37181, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 37181, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f8338", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f9270", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37184, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 37184, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7f91c0", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 37184, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 37184, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7f9288", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37193, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 37193, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f91d0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37193, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 37193, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f85e0", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7f9410", - "kind": "FunctionDecl", - "loc": { - "offset": 37220, - "file": "ToString.cpp", - "line": 1226, - "col": 18, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 37203, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 37304, - "line": 1228, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3af020", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIbEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "bool (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "bool" - }, - "inner": [ - { - "id": "0x564d8c93db70", - "kind": "BuiltinType", - "type": { - "qualType": "bool" - } - } - ] - }, - { - "id": "0x564d8e7f9340", - "kind": "ParmVarDecl", - "loc": { - "offset": 37248, - "line": 1226, - "col": 46, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37229, - "col": 27, - "tokLen": 5 - }, - "end": { - "offset": 37248, - "col": 46, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f97b8", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37251, - "col": 49, - "tokLen": 1 - }, - "end": { - "offset": 37304, - "line": 1228, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f97a8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37257, - "line": 1227, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 37301, - "col": 49, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9778", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37264, - "col": 12, - "tokLen": 8 - }, - "end": { - "offset": 37301, - "col": 49, - "tokLen": 1 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f9760", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37264, - "col": 12, - "tokLen": 8 - }, - "end": { - "offset": 37264, - "col": 12, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool (*)(const std::string &, defs::boolFormat)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f96d8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37264, - "col": 12, - "tokLen": 8 - }, - "end": { - "offset": 37264, - "col": 12, - "tokLen": 8 - } - }, - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e3af5f0", - "kind": "FunctionDecl", - "name": "StringTo", - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - } - } - } - ] - }, - { - "id": "0x564d8e7f9628", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37273, - "col": 21, - "tokLen": 1 - }, - "end": { - "offset": 37273, - "col": 21, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9340", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7f9698", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37276, - "col": 24, - "tokLen": 4 - }, - "end": { - "offset": 37294, - "col": 42, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74f70", - "kind": "EnumConstantDecl", - "name": "OneZero", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7f99d0", - "kind": "FunctionDecl", - "loc": { - "offset": 37312, - "file": "ToString.cpp", - "line": 1230, - "col": 6, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 37307, - "col": 1, - "tokLen": 4 - }, - "end": { - "offset": 38192, - "line": 1260, - "col": 1, - "tokLen": 1 - } - }, - "isUsed": true, - "previousDecl": "0x564d8e3af5f0", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEN15slsDetectorDefs10boolFormatE", - "type": { - "qualType": "bool (const std::string &, defs::boolFormat)" - }, - "inner": [ - { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "loc": { - "offset": 37340, - "line": 1230, - "col": 34, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37321, - "col": 15, - "tokLen": 5 - }, - "end": { - "offset": 37340, - "col": 34, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e7f98f0", - "kind": "ParmVarDecl", - "loc": { - "offset": 37360, - "col": 54, - "tokLen": 6 - }, - "range": { - "begin": { - "offset": 37343, - "col": 37, - "tokLen": 4 - }, - "end": { - "offset": 37360, - "col": 54, - "tokLen": 6 - } - }, - "isUsed": true, - "name": "format", - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - } - }, - { - "id": "0x564d8e7ff738", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37368, - "col": 62, - "tokLen": 1 - }, - "end": { - "offset": 38192, - "line": 1260, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9ad8", - "kind": "SwitchStmt", - "range": { - "begin": { - "offset": 37374, - "line": 1231, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 38190, - "line": 1259, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9ac0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37382, - "line": 1231, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37382, - "col": 13, - "tokLen": 6 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f9aa8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37382, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37382, - "col": 13, - "tokLen": 6 - } - }, - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7f9a88", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37382, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37382, - "col": 13, - "tokLen": 6 - } - }, - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f98f0", - "kind": "ParmVarDecl", - "name": "format", - "type": { - "desugaredQualType": "slsDetectorDefs::boolFormat", - "qualType": "defs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ff708", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37390, - "col": 21, - "tokLen": 1 - }, - "end": { - "offset": 38190, - "line": 1259, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9bb8", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37396, - "line": 1232, - "col": 5, - "tokLen": 4 - }, - "end": { - "offset": 37615, - "line": 1238, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7f9b98", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37401, - "line": 1232, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37419, - "col": 28, - "tokLen": 9 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0", - "inner": [ - { - "id": "0x564d8e7f9b80", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37401, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37419, - "col": 28, - "tokLen": 9 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7f9b50", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37401, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37419, - "col": 28, - "tokLen": 9 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74ec0", - "kind": "EnumConstantDecl", - "name": "TrueFalse", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7fc570", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37430, - "col": 39, - "tokLen": 1 - }, - "end": { - "offset": 37615, - "line": 1238, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7fafb8", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37440, - "line": 1233, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37476, - "line": 1234, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7faf60", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37444, - "line": 1233, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37449, - "col": 18, - "tokLen": 6 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7faf48", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37446, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37446, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7faf28", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37446, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37446, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7f9be0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37444, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37444, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7faf10", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37449, - "col": 18, - "tokLen": 6 - }, - "end": { - "offset": 37449, - "col": 18, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7f9c00", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37449, - "col": 18, - "tokLen": 6 - }, - "end": { - "offset": 37449, - "col": 18, - "tokLen": 6 - } - }, - "type": { - "qualType": "const char[5]" - }, - "valueCategory": "lvalue", - "value": "\"true\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fafa8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37469, - "line": 1234, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37476, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7faf98", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37476, - "col": 20, - "tokLen": 4 - }, - "end": { - "offset": 37476, - "col": 20, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": true - } - ] - } - ] - }, - { - "id": "0x564d8e7fc388", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37490, - "line": 1235, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37527, - "line": 1236, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7fc330", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37494, - "line": 1235, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37499, - "col": 18, - "tokLen": 7 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7fc318", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37496, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37496, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fc2f8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37496, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37496, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7fafd8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37494, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37494, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7fc2e0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37499, - "col": 18, - "tokLen": 7 - }, - "end": { - "offset": 37499, - "col": 18, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7faff8", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37499, - "col": 18, - "tokLen": 7 - }, - "end": { - "offset": 37499, - "col": 18, - "tokLen": 7 - } - }, - "type": { - "qualType": "const char[6]" - }, - "valueCategory": "lvalue", - "value": "\"false\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fc378", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37520, - "line": 1236, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37527, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7fc368", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37527, - "col": 20, - "tokLen": 5 - }, - "end": { - "offset": 37527, - "col": 20, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": false - } - ] - } - ] - }, - { - "id": "0x564d8e7fc558", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 37542, - "line": 1237, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7fc540", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 37542, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7fc518", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 37548, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7fc4f8", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 37548, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7fc4f0", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7fc4c0", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 37548, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37608, - "col": 75, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7fc4a8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37561, - "col": 28, - "tokLen": 47 - }, - "end": { - "offset": 37561, - "col": 28, - "tokLen": 47 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fc420", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37561, - "col": 28, - "tokLen": 47 - }, - "end": { - "offset": 37561, - "col": 28, - "tokLen": 47 - } - }, - "type": { - "qualType": "const char[46]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean. Expecting 'true' or 'false'.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7fc650", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37621, - "line": 1239, - "col": 5, - "tokLen": 4 - }, - "end": { - "offset": 37828, - "line": 1245, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7fc630", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37626, - "line": 1239, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37644, - "col": 28, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "1", - "inner": [ - { - "id": "0x564d8e7fc618", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37626, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37644, - "col": 28, - "tokLen": 5 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7fc5e8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37626, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37644, - "col": 28, - "tokLen": 5 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74f18", - "kind": "EnumConstantDecl", - "name": "OnOff", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7fef78", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37651, - "col": 35, - "tokLen": 1 - }, - "end": { - "offset": 37828, - "line": 1245, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7fda28", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37661, - "line": 1240, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37695, - "line": 1241, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7fd9d0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37665, - "line": 1240, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37670, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7fd9b8", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37667, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37667, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fd998", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37667, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37667, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7fc678", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37665, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37665, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7fd980", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37670, - "col": 18, - "tokLen": 4 - }, - "end": { - "offset": 37670, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fc698", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37670, - "col": 18, - "tokLen": 4 - }, - "end": { - "offset": 37670, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"on\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fda18", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37688, - "line": 1241, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37695, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7fda08", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37695, - "col": 20, - "tokLen": 4 - }, - "end": { - "offset": 37695, - "col": 20, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": true - } - ] - } - ] - }, - { - "id": "0x564d8e7fedf8", - "kind": "IfStmt", - "range": { - "begin": { - "offset": 37709, - "line": 1242, - "col": 9, - "tokLen": 2 - }, - "end": { - "offset": 37744, - "line": 1243, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7feda0", - "kind": "CXXOperatorCallExpr", - "range": { - "begin": { - "offset": 37713, - "line": 1242, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37718, - "col": 18, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "adl": true, - "inner": [ - { - "id": "0x564d8e7fed88", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37715, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37715, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (*)(const basic_string, allocator> &, const char *)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fed68", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37715, - "col": 15, - "tokLen": 2 - }, - "end": { - "offset": 37715, - "col": 15, - "tokLen": 2 - } - }, - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e31ef10", - "kind": "FunctionDecl", - "name": "operator==", - "type": { - "qualType": "bool (const basic_string, allocator> &, const char *)" - } - } - } - ] - }, - { - "id": "0x564d8e7fda48", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37713, - "col": 13, - "tokLen": 1 - }, - "end": { - "offset": 37713, - "col": 13, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7fed50", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37718, - "col": 18, - "tokLen": 5 - }, - "end": { - "offset": 37718, - "col": 18, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fda68", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37718, - "col": 18, - "tokLen": 5 - }, - "end": { - "offset": 37718, - "col": 18, - "tokLen": 5 - } - }, - "type": { - "qualType": "const char[4]" - }, - "valueCategory": "lvalue", - "value": "\"off\"" - } - ] - } - ] - }, - { - "id": "0x564d8e7fede8", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37737, - "line": 1243, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37744, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7fedd8", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37744, - "col": 20, - "tokLen": 5 - }, - "end": { - "offset": 37744, - "col": 20, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": false - } - ] - } - ] - }, - { - "id": "0x564d8e7fef60", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 37759, - "line": 1244, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7fef48", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 37759, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7fef20", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 37765, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7fef00", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 37765, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7feef8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7feec8", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 37765, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 37821, - "col": 71, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7feeb0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37778, - "col": 28, - "tokLen": 43 - }, - "end": { - "offset": 37778, - "col": 28, - "tokLen": 43 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7fee28", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 37778, - "col": 28, - "tokLen": 43 - }, - "end": { - "offset": 37778, - "col": 28, - "tokLen": 43 - } - }, - "type": { - "qualType": "const char[42]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean. Expecting 'on' or 'off'.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7ff058", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37834, - "line": 1246, - "col": 5, - "tokLen": 4 - }, - "end": { - "offset": 38116, - "line": 1256, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff038", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37839, - "line": 1246, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37857, - "col": 28, - "tokLen": 7 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "2", - "inner": [ - { - "id": "0x564d8e7ff020", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37839, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37857, - "col": 28, - "tokLen": 7 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8e7feff0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37839, - "col": 10, - "tokLen": 4 - }, - "end": { - "offset": 37857, - "col": 28, - "tokLen": 7 - } - }, - "type": { - "qualType": "slsDetectorDefs::boolFormat" - }, - "valueCategory": "prvalue", - "referencedDecl": { - "id": "0x564d8dc74f70", - "kind": "EnumConstantDecl", - "name": "OneZero", - "type": { - "qualType": "slsDetectorDefs::boolFormat" - } - } - } - ] - } - ] - }, - { - "id": "0x564d8e7ff580", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37866, - "col": 37, - "tokLen": 1 - }, - "end": { - "offset": 38116, - "line": 1256, - "col": 5, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff258", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 37876, - "line": 1247, - "col": 9, - "tokLen": 3 - }, - "end": { - "offset": 37909, - "col": 42, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff098", - "kind": "VarDecl", - "loc": { - "offset": 37880, - "col": 13, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 37876, - "col": 9, - "tokLen": 3 - }, - "end": { - "offset": 37908, - "col": 41, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "i", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e7ff208", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 37884, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 37908, - "col": 41, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ff1f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37884, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 37889, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ff1c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37884, - "col": 17, - "tokLen": 3 - }, - "end": { - "offset": 37889, - "col": 22, - "tokLen": 4 - } - }, - "type": { - "qualType": "int (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d66dd88", - "kind": "FunctionDecl", - "name": "stoi", - "type": { - "qualType": "int (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e7ff170", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37894, - "col": 27, - "tokLen": 1 - }, - "end": { - "offset": 37894, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7f9828", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e7ff240", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37897, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 37897, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e7ff190", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 37897, - "col": 30, - "tokLen": 7 - }, - "end": { - "offset": 37897, - "col": 30, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e7ff1a0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37906, - "col": 39, - "tokLen": 2 - }, - "end": { - "offset": 37906, - "col": 39, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7ff2a8", - "kind": "SwitchStmt", - "range": { - "begin": { - "offset": 37919, - "line": 1248, - "col": 9, - "tokLen": 6 - }, - "end": { - "offset": 38110, - "line": 1255, - "col": 9, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff290", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 37927, - "line": 1248, - "col": 17, - "tokLen": 1 - }, - "end": { - "offset": 37927, - "col": 17, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e7ff270", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 37927, - "col": 17, - "tokLen": 1 - }, - "end": { - "offset": 37927, - "col": 17, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ff098", - "kind": "VarDecl", - "name": "i", - "type": { - "qualType": "int" - } - } - } - ] - }, - { - "id": "0x564d8e7ff558", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 37930, - "col": 20, - "tokLen": 1 - }, - "end": { - "offset": 38110, - "line": 1255, - "col": 9, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff310", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37940, - "line": 1249, - "col": 9, - "tokLen": 4 - }, - "end": { - "offset": 37967, - "line": 1250, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7ff2f0", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37945, - "line": 1249, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37945, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0", - "inner": [ - { - "id": "0x564d8e7ff2d0", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37945, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37945, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - }, - { - "id": "0x564d8e7ff348", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 37960, - "line": 1250, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 37967, - "col": 20, - "tokLen": 5 - } - }, - "inner": [ - { - "id": "0x564d8e7ff338", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 37967, - "col": 20, - "tokLen": 5 - }, - "end": { - "offset": 37967, - "col": 20, - "tokLen": 5 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": false - } - ] - } - ] - }, - { - "id": "0x564d8e7ff398", - "kind": "CaseStmt", - "range": { - "begin": { - "offset": 37982, - "line": 1251, - "col": 9, - "tokLen": 4 - }, - "end": { - "offset": 38009, - "line": 1252, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ff378", - "kind": "ConstantExpr", - "range": { - "begin": { - "offset": 37987, - "line": 1251, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37987, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "1", - "inner": [ - { - "id": "0x564d8e7ff358", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 37987, - "col": 14, - "tokLen": 1 - }, - "end": { - "offset": 37987, - "col": 14, - "tokLen": 1 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "1" - } - ] - }, - { - "id": "0x564d8e7ff3d0", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 38002, - "line": 1252, - "col": 13, - "tokLen": 6 - }, - "end": { - "offset": 38009, - "col": 20, - "tokLen": 4 - } - }, - "inner": [ - { - "id": "0x564d8e7ff3c0", - "kind": "CXXBoolLiteralExpr", - "range": { - "begin": { - "offset": 38009, - "col": 20, - "tokLen": 4 - }, - "end": { - "offset": 38009, - "col": 20, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "value": true - } - ] - } - ] - }, - { - "id": "0x564d8e7ff538", - "kind": "DefaultStmt", - "range": { - "begin": { - "offset": 38023, - "line": 1253, - "col": 9, - "tokLen": 7 - }, - "end": { - "offset": 38099, - "line": 1254, - "col": 68, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff520", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 38044, - "col": 13, - "tokLen": 5 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ff508", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 38044, - "col": 13, - "tokLen": 5 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ff4e0", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 38050, - "col": 19, - "tokLen": 12 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7ff4c0", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 38050, - "col": 19, - "tokLen": 12 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ff4b8", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ff488", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 38050, - "col": 19, - "tokLen": 12 - }, - "end": { - "offset": 38099, - "col": 68, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7ff470", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38063, - "col": 32, - "tokLen": 36 - }, - "end": { - "offset": 38063, - "col": 32, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ff3f0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 38063, - "col": 32, - "tokLen": 36 - }, - "end": { - "offset": 38063, - "col": 32, - "tokLen": 36 - } - }, - "type": { - "qualType": "const char[35]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean. Expecting 0 or 1.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e7ff6e8", - "kind": "DefaultStmt", - "range": { - "begin": { - "offset": 38122, - "line": 1257, - "col": 5, - "tokLen": 7 - }, - "end": { - "offset": 38183, - "line": 1258, - "col": 53, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ff6d0", - "kind": "ExprWithCleanups", - "range": { - "begin": { - "offset": 38139, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "cleanupsHaveSideEffects": true, - "inner": [ - { - "id": "0x564d8e7ff6b8", - "kind": "CXXThrowExpr", - "range": { - "begin": { - "offset": 38139, - "col": 9, - "tokLen": 5 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "qualType": "void" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7ff690", - "kind": "CXXFunctionalCastExpr", - "range": { - "begin": { - "offset": 38145, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "castKind": "ConstructorConversion", - "conversionFunc": { - "id": "0x564d8d916e90", - "kind": "CXXConstructorDecl", - "name": "RuntimeError", - "type": { - "qualType": "void (const char *)" - } - }, - "inner": [ - { - "id": "0x564d8e7ff670", - "kind": "CXXBindTemporaryExpr", - "range": { - "begin": { - "offset": 38145, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "temp": "0x564d8e7ff668", - "dtor": { - "id": "0x564d8d917778", - "kind": "CXXDestructorDecl", - "name": "~RuntimeError", - "type": { - "qualType": "void () noexcept" - } - }, - "inner": [ - { - "id": "0x564d8e7ff638", - "kind": "CXXConstructExpr", - "range": { - "begin": { - "offset": 38145, - "col": 15, - "tokLen": 12 - }, - "end": { - "offset": 38183, - "col": 53, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "sls::RuntimeError", - "qualType": "RuntimeError" - }, - "valueCategory": "prvalue", - "ctorType": { - "qualType": "void (const char *)" - }, - "hadMultipleCandidates": true, - "constructionKind": "complete", - "inner": [ - { - "id": "0x564d8e7ff620", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38158, - "col": 28, - "tokLen": 25 - }, - "end": { - "offset": 38158, - "col": 28, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ff5b0", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 38158, - "col": 28, - "tokLen": 25 - }, - "end": { - "offset": 38158, - "col": 28, - "tokLen": 25 - } - }, - "type": { - "qualType": "const char[24]" - }, - "valueCategory": "lvalue", - "value": "\"Unknown boolean format.\"" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -}, -{ - "id": "0x564d8e7ff890", - "kind": "FunctionDecl", - "loc": { - "offset": 38215, - "file": "ToString.cpp", - "line": 1262, - "col": 21, - "tokLen": 8 - }, - "range": { - "begin": { - "offset": 38195, - "col": 1, - "tokLen": 8 - }, - "end": { - "offset": 38348, - "line": 1265, - "col": 1, - "tokLen": 1 - } - }, - "previousDecl": "0x564d8e3af830", - "name": "StringTo", - "mangledName": "_ZN3sls8StringToIlEET_RKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE", - "type": { - "qualType": "int64_t (const std::string &)" - }, - "inner": [ - { - "kind": "TemplateArgument", - "type": { - "qualType": "long" - }, - "inner": [ - { - "id": "0x564d8c93dc10", - "kind": "BuiltinType", - "type": { - "qualType": "long" - } - } - ] - }, - { - "id": "0x564d8e7ff7c0", - "kind": "ParmVarDecl", - "loc": { - "offset": 38243, - "line": 1262, - "col": 49, - "tokLen": 1 - }, - "range": { - "begin": { - "offset": 38224, - "col": 30, - "tokLen": 5 - }, - "end": { - "offset": 38243, - "col": 49, - "tokLen": 1 - } - }, - "isUsed": true, - "name": "s", - "type": { - "qualType": "const std::string &" - } - }, - { - "id": "0x564d8e800790", - "kind": "CompoundStmt", - "range": { - "begin": { - "offset": 38246, - "col": 52, - "tokLen": 1 - }, - "end": { - "offset": 38348, - "line": 1265, - "col": 1, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e800598", - "kind": "DeclStmt", - "range": { - "begin": { - "offset": 38252, - "line": 1263, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 38306, - "col": 59, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e7ffa60", - "kind": "VarDecl", - "loc": { - "offset": 38256, - "col": 9, - "tokLen": 4 - }, - "range": { - "begin": { - "offset": 38252, - "col": 5, - "tokLen": 3 - }, - "end": { - "offset": 38304, - "col": 57, - "tokLen": 2 - } - }, - "isUsed": true, - "name": "base", - "type": { - "qualType": "int" - }, - "init": "c", - "inner": [ - { - "id": "0x564d8e800568", - "kind": "ConditionalOperator", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38304, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e800508", - "kind": "BinaryOperator", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38292, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "qualType": "bool" - }, - "valueCategory": "prvalue", - "opcode": "!=", - "inner": [ - { - "id": "0x564d8e8003e0", - "kind": "CXXMemberCallExpr", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38274, - "col": 27, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e8003b0", - "kind": "MemberExpr", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38265, - "col": 18, - "tokLen": 4 - } - }, - "type": { - "qualType": "" - }, - "valueCategory": "prvalue", - "name": "find", - "isArrow": false, - "referencedMemberDecl": "0x564d8d6b6d18", - "inner": [ - { - "id": "0x564d8e7ffac8", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38263, - "col": 16, - "tokLen": 1 - }, - "end": { - "offset": 38263, - "col": 16, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ff7c0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - } - ] - }, - { - "id": "0x564d8e800410", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38270, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 38270, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char *" - }, - "valueCategory": "prvalue", - "castKind": "ArrayToPointerDecay", - "inner": [ - { - "id": "0x564d8e7ffb60", - "kind": "StringLiteral", - "range": { - "begin": { - "offset": 38270, - "col": 23, - "tokLen": 4 - }, - "end": { - "offset": 38270, - "col": 23, - "tokLen": 4 - } - }, - "type": { - "qualType": "const char[3]" - }, - "valueCategory": "lvalue", - "value": "\"0x\"" - } - ] - }, - { - "id": "0x564d8e800428", - "kind": "CXXDefaultArgExpr", - "range": { - "begin": {}, - "end": {} - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e7f2c98", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 101453, - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/bits/basic_string.h", - "line": 2973, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "IntegralCast", - "inner": [ - { - "id": "0x564d8d5a0090", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - }, - "end": { - "offset": 101453, - "col": 49, - "tokLen": 1, - "includedFrom": { - "file": "/usr/bin/../lib/gcc/x86_64-redhat-linux/15/../../../../include/c++/15/string" - } - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "0" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e8004f0", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38279, - "file": "ToString.cpp", - "line": 1263, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 38292, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "unsigned long", - "qualType": "typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e8004c0", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38279, - "col": 32, - "tokLen": 3 - }, - "end": { - "offset": 38292, - "col": 45, - "tokLen": 4 - } - }, - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e0aff60", - "kind": "VarDecl", - "name": "npos", - "type": { - "desugaredQualType": "const unsigned long", - "qualType": "const typename basic_string, allocator>::size_type", - "typeAliasDeclId": "0x564d8d686c40" - } - }, - "nonOdrUseReason": "constant" - } - ] - } - ] - }, - { - "id": "0x564d8e800528", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 38299, - "col": 52, - "tokLen": 2 - }, - "end": { - "offset": 38299, - "col": 52, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "16" - }, - { - "id": "0x564d8e800548", - "kind": "IntegerLiteral", - "range": { - "begin": { - "offset": 38304, - "col": 57, - "tokLen": 2 - }, - "end": { - "offset": 38304, - "col": 57, - "tokLen": 2 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "value": "10" - } - ] - } - ] - } - ] - }, - { - "id": "0x564d8e800780", - "kind": "ReturnStmt", - "range": { - "begin": { - "offset": 38312, - "line": 1264, - "col": 5, - "tokLen": 6 - }, - "end": { - "offset": 38345, - "col": 38, - "tokLen": 1 - } - }, - "inner": [ - { - "id": "0x564d8e800718", - "kind": "CallExpr", - "range": { - "begin": { - "offset": 38319, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 38345, - "col": 38, - "tokLen": 1 - } - }, - "type": { - "qualType": "long" - }, - "valueCategory": "prvalue", - "inner": [ - { - "id": "0x564d8e800700", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38319, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 38324, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "long (*)(const string &, size_t *, int)" - }, - "valueCategory": "prvalue", - "castKind": "FunctionToPointerDecay", - "inner": [ - { - "id": "0x564d8e800670", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38319, - "col": 12, - "tokLen": 3 - }, - "end": { - "offset": 38324, - "col": 17, - "tokLen": 4 - } - }, - "type": { - "qualType": "long (const string &, size_t *, int)" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8d6c6798", - "kind": "FunctionDecl", - "name": "stol", - "type": { - "qualType": "long (const string &, size_t *, int)" - } - } - } - ] - }, - { - "id": "0x564d8e800620", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38329, - "col": 22, - "tokLen": 1 - }, - "end": { - "offset": 38329, - "col": 22, - "tokLen": 1 - } - }, - "type": { - "desugaredQualType": "const std::basic_string", - "qualType": "const std::string", - "typeAliasDeclId": "0x564d8d3fbb20" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ff7c0", - "kind": "ParmVarDecl", - "name": "s", - "type": { - "qualType": "const std::string &" - } - } - }, - { - "id": "0x564d8e800750", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38332, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 38332, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "size_t *" - }, - "valueCategory": "prvalue", - "castKind": "NullToPointer", - "inner": [ - { - "id": "0x564d8e800640", - "kind": "CXXNullPtrLiteralExpr", - "range": { - "begin": { - "offset": 38332, - "col": 25, - "tokLen": 7 - }, - "end": { - "offset": 38332, - "col": 25, - "tokLen": 7 - } - }, - "type": { - "qualType": "std::nullptr_t" - }, - "valueCategory": "prvalue" - } - ] - }, - { - "id": "0x564d8e800768", - "kind": "ImplicitCastExpr", - "range": { - "begin": { - "offset": 38341, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 38341, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "prvalue", - "castKind": "LValueToRValue", - "inner": [ - { - "id": "0x564d8e800650", - "kind": "DeclRefExpr", - "range": { - "begin": { - "offset": 38341, - "col": 34, - "tokLen": 4 - }, - "end": { - "offset": 38341, - "col": 34, - "tokLen": 4 - } - }, - "type": { - "qualType": "int" - }, - "valueCategory": "lvalue", - "referencedDecl": { - "id": "0x564d8e7ffa60", - "kind": "VarDecl", - "name": "base", - "type": { - "qualType": "int" - } - } - } - ] - } - ] - } - ] - } - ] - } - ] -} -] \ No newline at end of file diff --git a/slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh b/slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh index 3da9f237e..fc4ce973e 100644 --- a/slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh +++ b/slsDetectorSoftware/generator/autocomplete/zsh_autocomplete.sh @@ -4,7 +4,7 @@ _sd() { -local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues datastream dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest include initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port power powerchip powerdac powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_streamdummyheader rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport " +local SLS_COMMANDS=" acquire activate adcclk adcenable adcenable10g adcindex adcinvert adclist adcname adcphase adcpipeline adcreg adcvpp apulse asamples autocompdisable badchannels blockingtrigger burstmode burstperiod bursts burstsl bustest cdsgain chipversion clearbit clearbusy clientversion clkdiv clkfreq clkphase collectionmode column compdisabletime confadc config configtransceiver counters currentsource dac dacindex daclist dacname dacvalues dbitclk dbitphase dbitpipeline defaultdac defaultpattern define_bit define_reg definelist_bit definelist_reg delay delayl detectorserverversion detsize diodelay dpulse dr drlist dsamples execcommand exptime exptime1 exptime2 exptime3 extrastoragecells extsampling extsamplingsrc extsig fformat filtercells filterresistor findex firmwaretest firmwareversion fliprows flowcontrol10g fmaster fname foverwrite fpath framecounter frames framesl frametime free fwrite gaincaps gainmode gappixels gatedelay gatedelay1 gatedelay2 gatedelay3 gates getbit hardwareversion highvoltage hostname im_a im_b im_c im_d im_io imagetest include initialchecks inj_ch interpolation interruptsubframe kernelversion lastclient led lock master maxadcphaseshift maxclkphaseshift maxdbitphaseshift measuredperiod measuredsubperiod moduleid nextframenumber nmod numinterfaces overflow packageversion parallel parameters partialreset patfname patioctrl patlimits patloop patloop0 patloop1 patloop2 patmask patnloop patnloop0 patnloop1 patnloop2 patsetbit pattern patternstart patwait patwait0 patwait1 patwait2 patwaittime patwaittime0 patwaittime1 patwaittime2 patword pedestalmode period periodl polarity port power powerchip powerdac powerindex powerlist powername powervalues programfpga pulse pulsechip pulsenmove pumpprobe quad ratecorr readnrows readout readoutspeed readoutspeedlist rebootcontroller reg resetdacs resetfpga romode row runclk runtime rx_arping rx_clearroi rx_dbitlist rx_dbitoffset rx_dbitreorder rx_discardpolicy rx_fifodepth rx_frameindex rx_framescaught rx_framesperfile rx_hostname rx_jsonaddheader rx_jsonpara rx_lastclient rx_lock rx_missingpackets rx_padding rx_printconfig rx_realudpsocksize rx_roi rx_silent rx_start rx_status rx_stop rx_streamdummyheader rx_tcpport rx_threads rx_udpsocksize rx_version rx_zmqfreq rx_zmqhwm rx_zmqip rx_zmqport rx_zmqstartfnum rx_zmqstream samples savepattern scan scanerrmsg selinterface serialnumber setbit settings settingslist settingspath signalindex signallist signalname sleep slowadc slowadcindex slowadclist slowadcname slowadcvalues start status stop stopport storagecell_delay storagecell_start subdeadtime subexptime sync syncclk temp_10ge temp_adc temp_control temp_dcdc temp_event temp_fpga temp_fpgaext temp_fpgafl temp_fpgafr temp_slowadc temp_sodl temp_sodr temp_threshold templist tempvalues tengiga threshold thresholdnotb timing timing_info_decoder timinglist timingsource top transceiverenable trigger triggers triggersl trimbits trimen trimval tsamples txdelay txdelay_frame txdelay_left txdelay_right type udp_cleardst udp_datastream udp_dstip udp_dstip2 udp_dstlist udp_dstmac udp_dstmac2 udp_dstport udp_dstport2 udp_firstdst udp_numdst udp_reconfigure udp_srcip udp_srcip2 udp_srcmac udp_srcmac2 udp_validate update updatedetectorserver updatekernel updatemode user v_limit vchip_comp_adc vchip_comp_fe vchip_cs vchip_opa_1st vchip_opa_fd vchip_ref_comp_fe versions veto vetoalg vetofile vetophoton vetoref vetostream virtual vm_a vm_b vm_c vm_d vm_io zmqhwm zmqip zmqport " __acquire() { FCN_RETURN="" return 0 @@ -524,23 +524,6 @@ fi fi return 0 } -__datastream() { -FCN_RETURN="" -if [[ ${IS_GET} -eq 1 ]]; then -if [[ "${cword}" == "2" ]]; then -FCN_RETURN="bottom left right top" -fi -fi -if [[ ${IS_GET} -eq 0 ]]; then -if [[ "${cword}" == "2" ]]; then -FCN_RETURN="bottom left right top" -fi -if [[ "${cword}" == "3" ]]; then -FCN_RETURN="0 1" -fi -fi -return 0 -} __dbitclk() { FCN_RETURN="" if [[ ${IS_GET} -eq 1 ]]; then @@ -2917,6 +2900,23 @@ __udp_cleardst() { FCN_RETURN="" return 0 } +__udp_datastream() { +FCN_RETURN="" +if [[ ${IS_GET} -eq 1 ]]; then +if [[ "${cword}" == "2" ]]; then +FCN_RETURN="bottom left right top" +fi +fi +if [[ ${IS_GET} -eq 0 ]]; then +if [[ "${cword}" == "2" ]]; then +FCN_RETURN="bottom left right top" +fi +if [[ "${cword}" == "3" ]]; then +FCN_RETURN="0 1" +fi +fi +return 0 +} __udp_dstip() { FCN_RETURN="" if [[ ${IS_GET} -eq 0 ]]; then diff --git a/slsDetectorSoftware/generator/commands.yaml b/slsDetectorSoftware/generator/commands.yaml index 03a59ede3..2fd884845 100644 --- a/slsDetectorSoftware/generator/commands.yaml +++ b/slsDetectorSoftware/generator/commands.yaml @@ -826,15 +826,6 @@ nextframenumber: function: setNextFrameNumber input_types: [ uint64_t ] -numinterfaces: - help: "[1, 2]\n\t[Jungfrau][Moench] Number of udp interfaces to stream data from detector. Default: 1.\n\tAlso enables second interface in receiver for listening (Writes a file per interface if writing enabled).\n\tAlso restarts client and receiver zmq sockets if zmq streaming enabled.\n\t[Eiger] Only gets with result 2." - inherit_actions: INTEGER_COMMAND_VEC_ID - actions: - GET: - function: getNumberofUDPInterfaces - PUT: - function: setNumberofUDPInterfaces - selinterface: help: "[0, 1]\n\t[Jungfrau][Moench] The udp interface to stream data from detector. Effective only when number of interfaces is 1. Default: 0 (outer)" inherit_actions: INTEGER_COMMAND_VEC_ID @@ -1521,6 +1512,15 @@ zmqport: function: setClientZmqPort ################# INTEGER_COMMAND_SET_NOID_GET_ID ############ +numinterfaces: + help: "[1, 2]\n\t[Jungfrau][Moench] Number of udp interfaces to stream data from detector. Default: 1.\n\tAlso enables second interface in receiver for listening (Writes a file per interface if writing enabled).\n\tAlso restarts client and receiver zmq sockets if zmq streaming enabled.\n\t[Eiger] Only gets with result 2." + inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID + actions: + GET: + function: getNumberofUDPInterfaces + PUT: + function: setNumberofUDPInterfaces + sync: inherit_actions: INTEGER_COMMAND_SET_NOID_GET_ID help: "[0, 1]\n\t[Jungfrau][Moench] Enables or disables synchronization between modules. Sync mode requires at least one master configured. Also requires flatband cabling between master and slave with termination board." @@ -3617,13 +3617,13 @@ quad: cast_input: [ true ] output: [ args.front() ] -datastream: - help: "[left|right] [0, 1]\n\t[Eiger] Enables or disables data streaming from left or/and right side of detector for 10 GbE mode. 1 (enabled) by default." +udp_datastream: + help: "[left|right|top|bottom] [0, 1]\n\tEnables or disables UDP data streaming from left or right of 10GbE UDP port of the detector. Options: left, right. Both ports are enabled (1) by default.\n\tEnables or disables UDP data streaming from the top or bottom of receiver. This option is available only when numinterfaces is set to 2. Options: top, bottom. Both interfaces are enabled (1) by default." actions: GET: argc: 1 require_det_id: true - function: getDataStream + function: getUDPDataStream input: [ 'args[0]' ] input_types: [ defs::portPosition ] cast_input: [ true ] @@ -3631,7 +3631,7 @@ datastream: PUT: argc: 2 require_det_id: true - function: setDataStream + function: setUDPDataStream input: [ 'args[0]', 'args[1]' ] input_types: [ defs::portPosition, bool ] cast_input: [ true, true ] diff --git a/slsDetectorSoftware/generator/deprecated_commands.yaml b/slsDetectorSoftware/generator/deprecated_commands.yaml index 7c3b8038c..31491851f 100644 --- a/slsDetectorSoftware/generator/deprecated_commands.yaml +++ b/slsDetectorSoftware/generator/deprecated_commands.yaml @@ -1,4 +1,3 @@ -#configuration detectorversion: firmwareversion softwareversion: detectorserverversion receiverversion: rx_version @@ -8,8 +7,6 @@ detsizechan: detsize trimdir: settingspath settingsdir: settingspath flippeddatax: fliprows - -#acquisition parameters cycles: triggers cyclesl: triggersl clkdivider: readoutspeed @@ -18,10 +15,6 @@ vhighvoltage: highvoltage digitest: imagetest filter: filterresistor readnlines: readnrows - -# temperature - -# super old dacs vtr: vtrim vrf: vrpreamp vrs: vrshaper @@ -33,8 +26,6 @@ vshaperneg: vrshaper_n viinsh: vishaper vpl: vcal_n vph: vcal_p - -# dacs vthreshold: dac vsvp: dac vsvn: dac @@ -93,17 +84,11 @@ vb_sda: dac vcasc_sfp: dac vipre_cds: dac ibias_sfp: dac - - defaultdacs: resetdacs - -#acquisition busy: clearbusy receiver: rx_status framescaught: rx_framescaught startingfnum: nextframenumber - -#Network Configuration (Detector<->Receiver) detectorip: udp_srcip detectorip2: udp_srcip2 detectormac: udp_srcmac @@ -118,15 +103,11 @@ flowcontrol_10g: flowcontrol10g txndelay_frame: txdelay_frame txndelay_left: txdelay_left txndelay_right: txdelay_right - -#Receiver Config r_silent: rx_silent r_discardpolicy: rx_discardpolicy r_padding: rx_padding r_lock: rx_lock r_lastclient: rx_lastclient - -#File fileformat: fformat outdir: fpath index: findex @@ -134,23 +115,13 @@ enablefwrite: fwrite masterfile: fmaster overwrite: foverwrite r_framesperfile: rx_framesperfile - -#ZMQ Streaming Parameters (Receiver<->Client) r_readfreq: rx_zmqfreq rx_readfreq: rx_zmqfreq rx_datastream: rx_zmqstream - -#Eiger Specific resmat: partialreset - -#Jungfrau Specific storagecells: extrastoragecells auto_comp_disable: autocompdisable comp_disable_time: compdisabletime - -#Gotthard2 Specific -#Mythen3 Specific -#CTB Specific adc: slowadc flags: romode i_a: im_a @@ -158,16 +129,10 @@ i_b: im_b i_c: im_c i_d: im_d i_io: im_io - -#Pattern patternX: pattern -#Moench - -#Advanced copydetectorserver: updatedetectorserver - -#Insignificant nframes: framecounter now: runtime timestamp: frametime -frameindex: rx_frameindex \ No newline at end of file +frameindex: rx_frameindex +datastream: udp_datastream \ No newline at end of file diff --git a/slsDetectorSoftware/generator/extended_commands.yaml b/slsDetectorSoftware/generator/extended_commands.yaml index f284c0a2e..a47bc1582 100644 --- a/slsDetectorSoftware/generator/extended_commands.yaml +++ b/slsDetectorSoftware/generator/extended_commands.yaml @@ -2038,53 +2038,6 @@ dacvalues: help: '' infer_action: true is_description: true -datastream: - actions: - GET: - args: - - arg_types: - - defs::portPosition - argc: 1 - cast_input: - - true - check_det_id: false - convert_det_id: true - function: getDataStream - input: - - args[0] - input_types: - - defs::portPosition - output: - - OutString(t) - require_det_id: true - store_result_in_t: true - PUT: - args: - - arg_types: - - defs::portPosition - - bool - argc: 2 - cast_input: - - true - - true - check_det_id: false - convert_det_id: true - function: setDataStream - input: - - args[0] - - args[1] - input_types: - - defs::portPosition - - bool - output: - - ToString(args) - require_det_id: true - store_result_in_t: false - command_name: datastream - function_alias: datastream - help: "[left|right] [0, 1]\n\t[Eiger] Enables or disables data streaming from left\ - \ or/and right side of detector for 10 GbE mode. 1 (enabled) by default." - infer_action: true dbitclk: actions: GET: @@ -5671,7 +5624,7 @@ numinterfaces: argc: 1 cast_input: - true - check_det_id: false + check_det_id: true convert_det_id: true function: setNumberofUDPInterfaces input: @@ -5680,7 +5633,7 @@ numinterfaces: - int output: - args.front() - require_det_id: true + require_det_id: false store_result_in_t: false command_name: numinterfaces function_alias: numinterfaces @@ -12035,6 +11988,56 @@ udp_cleardst: help: "\n\tClears udp destination details on the detector." infer_action: true template: true +udp_datastream: + actions: + GET: + args: + - arg_types: + - defs::portPosition + argc: 1 + cast_input: + - true + check_det_id: false + convert_det_id: true + function: getUDPDataStream + input: + - args[0] + input_types: + - defs::portPosition + output: + - OutString(t) + require_det_id: true + store_result_in_t: true + PUT: + args: + - arg_types: + - defs::portPosition + - bool + argc: 2 + cast_input: + - true + - true + check_det_id: false + convert_det_id: true + function: setUDPDataStream + input: + - args[0] + - args[1] + input_types: + - defs::portPosition + - bool + output: + - ToString(args) + require_det_id: true + store_result_in_t: false + command_name: udp_datastream + function_alias: udp_datastream + help: "[left|right|top|bottom] [0, 1]\n\tEnables or disables UDP data streaming\ + \ from left or right of 10GbE UDP port of the detector. Options: left, right.\ + \ Both ports are enabled (1) by default.\n\tEnables or disables UDP data streaming\ + \ from the top or bottom of receiver. This option is available only when numinterfaces\ + \ is set to 2. Options: top, bottom. Both interfaces are enabled (1) by default." + infer_action: true udp_dstip: actions: GET: diff --git a/slsDetectorSoftware/include/sls/Detector.h b/slsDetectorSoftware/include/sls/Detector.h index 1203b41ad..b3669a6a3 100644 --- a/slsDetectorSoftware/include/sls/Detector.h +++ b/slsDetectorSoftware/include/sls/Detector.h @@ -719,8 +719,9 @@ class Detector { * restarts client and receiver zmq sockets if zmq streaming enabled. \n * [Gotthard2] second interface enabled to send veto information via 10Gbps * for debugging. By default, if veto enabled, it is sent via 2.5 gbps - * interface. \nSetting this resets the receiver roi */ - void setNumberofUDPInterfaces(int n, Positions pos = {}); + * interface. \nSetting this resets the receiver roi and any udp datastream + * disables */ + void setNumberofUDPInterfaces(int n); /** [Jungfrau][Moench] */ Result getSelectedUDPInterface(Positions pos = {}) const; @@ -897,6 +898,37 @@ class Detector { */ void setTransmissionDelay(int step); + /** [Eiger] Returns whether the 10GbE UDP data stream from detector is + * enabled. Options: LEFT, RIGHT [Jungfrau][Moench] Returns whether the UDP + * data stream from receiver is enabled. Options: TOP, BOTTOM + * + */ + Result getUDPDataStream(const defs::portPosition port, + Positions pos = {}) const; + + /** [Eiger] Enables or disables UDP data streaming from left or right of + * 10GbE UDP port of the detector. Default: enabled. Options: LEFT, RIGHT \n + * [Jungfrau][Moench] Enables or disables UDP data streaming from the top or + * bottom of receiver. Default: enabled. Options: TOP, BOTTOM. This option + * is available only when numinterfaces is set to 2. + */ + void setUDPDataStream(const defs::portPosition port, const bool enable, + Positions pos = {}); + + /** List of disabled UDP ports with index (moduleIndex * 2 + portIndex), + * where portIndex is 0 for BOTTOM/LEFT port, and 1 for TOP/RIGHT port. + * It is the index with 'd' in the file name when writing data. \n + * [Eiger] LEFT, RIGHT + * [Jungfrau][Moench] TOP, BOTTOM + * This feature is available only when numinterfaces is set to 2. + */ + std::vector getRxDisabledUDPPortIndices() const; + + /** list of possible port positions. + * [Eiger] LEFT, RIGHT + * [Jungfrau][Moench] TOP, BOTTOM + */ + std::vector getPortPositionList() const; ///@} /** @name Receiver Configuration */ @@ -1252,16 +1284,6 @@ class Detector { * hardware required). */ void setQuad(const bool enable); - /** [Eiger] */ - Result getDataStream(const defs::portPosition port, - Positions pos = {}) const; - - /** [Eiger] enable or disable data streaming from left or right of detector - * for 10GbE. Default: enabled - */ - void setDataStream(const defs::portPosition port, const bool enable, - Positions pos = {}); - /** [Eiger] Advanced */ Result getTop(Positions pos = {}) const; @@ -2272,7 +2294,7 @@ class Detector { private: std::vector getValidPortNumbers(uint16_t start_port); void updateRxRateCorrections(); - void setNumberofUDPInterfaces_(int n, Positions pos); + void setNumberofUDPInterfaces_(int n); }; } // namespace sls diff --git a/slsDetectorSoftware/src/Caller.cpp b/slsDetectorSoftware/src/Caller.cpp index b2212d542..3278b0889 100644 --- a/slsDetectorSoftware/src/Caller.cpp +++ b/slsDetectorSoftware/src/Caller.cpp @@ -2426,82 +2426,6 @@ std::string Caller::dacname(int action) { return os.str(); } -std::string Caller::datastream(int action) { - - std::ostringstream os; - // print help - if (action == slsDetectorDefs::HELP_ACTION) { - os << R"V0G0N([left|right] [0, 1] - [Eiger] Enables or disables data streaming from left or/and right side of detector for 10 GbE mode. 1 (enabled) by default. )V0G0N" - << std::endl; - return os.str(); - } - - // check if action and arguments are valid - if (action == slsDetectorDefs::GET_ACTION) { - if (1 && args.size() != 1) { - throw RuntimeError("Wrong number of arguments for action GET"); - } - - if (args.size() == 1) { - try { - StringTo(args[0]); - } catch (...) { - throw RuntimeError( - "Could not convert argument 0 to defs::portPosition"); - } - } - - } - - else if (action == slsDetectorDefs::PUT_ACTION) { - if (1 && args.size() != 2) { - throw RuntimeError("Wrong number of arguments for action PUT"); - } - - if (args.size() == 2) { - try { - StringTo(args[0]); - } catch (...) { - throw RuntimeError( - "Could not convert argument 0 to defs::portPosition"); - } - try { - StringTo(args[1]); - } catch (...) { - throw RuntimeError("Could not convert argument 1 to bool"); - } - } - - } - - else { - - throw RuntimeError("INTERNAL ERROR: Invalid action: supported actions " - "are ['GET', 'PUT']"); - } - - // generate code for each action - if (action == slsDetectorDefs::GET_ACTION) { - if (args.size() == 1) { - auto arg0 = StringTo(args[0]); - auto t = det->getDataStream(arg0, std::vector{det_id}); - os << OutString(t) << '\n'; - } - } - - if (action == slsDetectorDefs::PUT_ACTION) { - if (args.size() == 2) { - auto arg0 = StringTo(args[0]); - auto arg1 = StringTo(args[1]); - det->setDataStream(arg0, arg1, std::vector{det_id}); - os << ToString(args) << '\n'; - } - } - - return os.str(); -} - std::string Caller::dbitclk(int action) { std::ostringstream os; @@ -7052,8 +6976,12 @@ std::string Caller::numinterfaces(int action) { if (action == slsDetectorDefs::PUT_ACTION) { if (args.size() == 1) { + if (det_id != -1) { + throw RuntimeError( + "Cannot execute numinterfaces at module level"); + } auto arg0 = StringTo(args[0]); - det->setNumberofUDPInterfaces(arg0, std::vector{det_id}); + det->setNumberofUDPInterfaces(arg0); os << args.front() << '\n'; } } @@ -14985,6 +14913,83 @@ std::string Caller::udp_cleardst(int action) { return os.str(); } +std::string Caller::udp_datastream(int action) { + + std::ostringstream os; + // print help + if (action == slsDetectorDefs::HELP_ACTION) { + os << R"V0G0N([left|right|top|bottom] [0, 1] + Enables or disables UDP data streaming from left or right of 10GbE UDP port of the detector. Options: left, right. Both ports are enabled (1) by default. + Enables or disables UDP data streaming from the top or bottom of receiver. This option is available only when numinterfaces is set to 2. Options: top, bottom. Both interfaces are enabled (1) by default. )V0G0N" + << std::endl; + return os.str(); + } + + // check if action and arguments are valid + if (action == slsDetectorDefs::GET_ACTION) { + if (1 && args.size() != 1) { + throw RuntimeError("Wrong number of arguments for action GET"); + } + + if (args.size() == 1) { + try { + StringTo(args[0]); + } catch (...) { + throw RuntimeError( + "Could not convert argument 0 to defs::portPosition"); + } + } + + } + + else if (action == slsDetectorDefs::PUT_ACTION) { + if (1 && args.size() != 2) { + throw RuntimeError("Wrong number of arguments for action PUT"); + } + + if (args.size() == 2) { + try { + StringTo(args[0]); + } catch (...) { + throw RuntimeError( + "Could not convert argument 0 to defs::portPosition"); + } + try { + StringTo(args[1]); + } catch (...) { + throw RuntimeError("Could not convert argument 1 to bool"); + } + } + + } + + else { + + throw RuntimeError("INTERNAL ERROR: Invalid action: supported actions " + "are ['GET', 'PUT']"); + } + + // generate code for each action + if (action == slsDetectorDefs::GET_ACTION) { + if (args.size() == 1) { + auto arg0 = StringTo(args[0]); + auto t = det->getUDPDataStream(arg0, std::vector{det_id}); + os << OutString(t) << '\n'; + } + } + + if (action == slsDetectorDefs::PUT_ACTION) { + if (args.size() == 2) { + auto arg0 = StringTo(args[0]); + auto arg1 = StringTo(args[1]); + det->setUDPDataStream(arg0, arg1, std::vector{det_id}); + os << ToString(args) << '\n'; + } + } + + return os.str(); +} + std::string Caller::udp_dstlist(int action) { std::ostringstream os; diff --git a/slsDetectorSoftware/src/Caller.h b/slsDetectorSoftware/src/Caller.h index 5b5633297..75297d84e 100644 --- a/slsDetectorSoftware/src/Caller.h +++ b/slsDetectorSoftware/src/Caller.h @@ -105,7 +105,6 @@ class Caller { std::string daclist(int action); std::string dacname(int action); std::string dacvalues(int action); - std::string datastream(int action); std::string dbitclk(int action); std::string dbitphase(int action); std::string dbitpipeline(int action); @@ -345,6 +344,7 @@ class Caller { std::string txdelay_right(int action); std::string type(int action); std::string udp_cleardst(int action); + std::string udp_datastream(int action); std::string udp_dstip(int action); std::string udp_dstip2(int action); std::string udp_dstlist(int action); @@ -474,7 +474,6 @@ class Caller { {"daclist", &Caller::daclist}, {"dacname", &Caller::dacname}, {"dacvalues", &Caller::dacvalues}, - {"datastream", &Caller::datastream}, {"dbitclk", &Caller::dbitclk}, {"dbitphase", &Caller::dbitphase}, {"dbitpipeline", &Caller::dbitpipeline}, @@ -718,6 +717,7 @@ class Caller { {"txdelay_right", &Caller::txdelay_right}, {"type", &Caller::type}, {"udp_cleardst", &Caller::udp_cleardst}, + {"udp_datastream", &Caller::udp_datastream}, {"udp_dstip", &Caller::udp_dstip}, {"udp_dstip2", &Caller::udp_dstip2}, {"udp_dstlist", &Caller::udp_dstlist}, @@ -903,6 +903,7 @@ class Caller { {"now", "runtime"}, {"timestamp", "frametime"}, {"frameindex", "rx_frameindex"}, + {"datastream", "udp_datastream"}, }; diff --git a/slsDetectorSoftware/src/CtbConfig.cpp b/slsDetectorSoftware/src/CtbConfig.cpp index b1117e9ca..2bdb0dafe 100644 --- a/slsDetectorSoftware/src/CtbConfig.cpp +++ b/slsDetectorSoftware/src/CtbConfig.cpp @@ -1,6 +1,6 @@ #include "CtbConfig.h" -#include "SharedMemory.h" +#include "sls/SharedMemory.h" #include "sls/ToString.h" #include "sls/string_utils.h" diff --git a/slsDetectorSoftware/src/Detector.cpp b/slsDetectorSoftware/src/Detector.cpp index 1b15819f6..121b144d6 100644 --- a/slsDetectorSoftware/src/Detector.cpp +++ b/slsDetectorSoftware/src/Detector.cpp @@ -1082,17 +1082,17 @@ Result Detector::getNumberofUDPInterfaces(Positions pos) const { return pimpl->Parallel(&Module::getNumberofUDPInterfacesFromShm, pos); } -void Detector::setNumberofUDPInterfaces(int n, Positions pos) { +void Detector::setNumberofUDPInterfaces(int n) { auto detType = getDetectorType().squash(); if (detType != defs::JUNGFRAU && detType != defs::MOENCH) { throw RuntimeError( "Cannot set number of udp interfaces for this detector."); } // also called by vetostream (for gotthard2) - setNumberofUDPInterfaces_(n, pos); + setNumberofUDPInterfaces_(n); } -void Detector::setNumberofUDPInterfaces_(int n, Positions pos) { +void Detector::setNumberofUDPInterfaces_(int n) { if (!size()) { throw RuntimeError("No modules added."); } @@ -1102,10 +1102,10 @@ void Detector::setNumberofUDPInterfaces_(int n, Positions pos) { bool previouslyReceiverStreaming = false; uint16_t rxStartingPort = 0; if (useReceiver) { - previouslyReceiverStreaming = getRxZmqDataStream(pos).squash(true); + previouslyReceiverStreaming = getRxZmqDataStream().squash(true); rxStartingPort = getRxZmqPort({0}).squash(0); } - pimpl->Parallel(&Module::setNumberofUDPInterfaces, pos, n); + pimpl->Parallel(&Module::setNumberofUDPInterfaces, {}, n); // ensure receiver zmq socket ports are multiplied by 2 (2 interfaces) setClientZmqPort(clientStartingPort, -1); if (getUseReceiverFlag().squash(false)) { @@ -1117,8 +1117,8 @@ void Detector::setNumberofUDPInterfaces_(int n, Positions pos) { pimpl->setDataStreamingToClient(true); } if (previouslyReceiverStreaming) { - setRxZmqDataStream(false, pos); - setRxZmqDataStream(true, pos); + setRxZmqDataStream(false); + setRxZmqDataStream(true); } } @@ -1317,6 +1317,24 @@ void Detector::setTransmissionDelay(int step) { pimpl->setTransmissionDelay(step); } +Result Detector::getUDPDataStream(const defs::portPosition port, + Positions pos) const { + return pimpl->getUDPDataStream(port, pos); +} + +void Detector::setUDPDataStream(const defs::portPosition port, + const bool enable, Positions pos) { + pimpl->setUDPDataStream(port, enable, pos); +} + +std::vector Detector::getRxDisabledUDPPortIndices() const { + return pimpl->getRxDisabledUDPPortIndices(); +} + +std::vector Detector::getPortPositionList() const { + return pimpl->getPortPositionList(); +} + // Receiver Result Detector::getUseReceiverFlag(Positions pos) const { @@ -1750,16 +1768,6 @@ void Detector::setQuad(const bool enable) { pimpl->Parallel(&Module::setQuad, {}, enable); } -Result Detector::getDataStream(const defs::portPosition port, - Positions pos) const { - return pimpl->Parallel(&Module::getDataStream, pos, port); -} - -void Detector::setDataStream(const defs::portPosition port, const bool enable, - Positions pos) { - pimpl->Parallel(&Module::setDataStream, pos, port, enable); -} - Result Detector::getTop(Positions pos) const { return pimpl->Parallel(&Module::getTop, pos); } @@ -2012,7 +2020,7 @@ void Detector::setVetoStream(defs::streamingInterface interface, ? 2 : 1); if (numinterfaces != old_numinterfaces) { - setNumberofUDPInterfaces_(numinterfaces, pos); + setNumberofUDPInterfaces_(numinterfaces); } } diff --git a/slsDetectorSoftware/src/DetectorImpl.cpp b/slsDetectorSoftware/src/DetectorImpl.cpp index 101cf6939..fd08b8bf5 100644 --- a/slsDetectorSoftware/src/DetectorImpl.cpp +++ b/slsDetectorSoftware/src/DetectorImpl.cpp @@ -2,7 +2,7 @@ // Copyright (C) 2021 Contributors to the SLS Detector Package #include "DetectorImpl.h" #include "Module.h" -#include "SharedMemory.h" +#include "sls/SharedMemory.h" #include "sls/ZmqSocket.h" #include "sls/detectorData.h" #include "sls/file_utils.h" @@ -1126,10 +1126,17 @@ int DetectorImpl::acquire() { // start receiver if (receiver) { - Parallel(&Module::startReceiver, {}); - } - startProcessingThread(receiver); + // to catch dummy zmq packets for disabled ports, + // start processing thread before startReceiver + if (dataReady != nullptr) + startRxZmqProcessingThread(); + + Parallel(&Module::startReceiver, {}); + + if (dataReady == nullptr) + startRxProgressThread(); + } // start and read all try { @@ -1314,53 +1321,46 @@ void DetectorImpl::printProgress(double progress) { std::cout << '\r' << std::flush; } -void DetectorImpl::startProcessingThread(bool receiver) { +void DetectorImpl::startRxZmqProcessingThread() { dataProcessingThread = - std::thread(&DetectorImpl::processData, this, receiver); + std::thread(&DetectorImpl::readFrameFromReceiver, this); } -void DetectorImpl::processData(bool receiver) { - if (receiver) { - if (dataReady != nullptr) { - readFrameFromReceiver(); - } - // only update progress - else { - LOG(logINFO) << "Type 'q' and hit enter to stop acquisition"; - double progress = 0; - printProgress(progress); +void DetectorImpl::startRxProgressThread() { + dataProcessingThread = std::thread(&DetectorImpl::printRxProgress, this); +} - while (true) { - // to exit acquire by typing q - if (kbhit() != 0) { - if (fgetc(stdin) == 'q') { - LOG(logINFO) - << "Caught the command to stop acquisition"; - stopDetector({}); - } - } - // get and print progress - double temp = - (double)Parallel(&Module::getReceiverProgress, {0}) - .squash(); - if (temp != progress) { - printProgress(progress); - progress = temp; - } +void DetectorImpl::printRxProgress() { + LOG(logINFO) << "Type 'q' and hit enter to stop acquisition"; + double progress = 0; + printProgress(progress); - // exiting loop - if (getJoinThreadFlag()) { - // print progress one final time before exiting - progress = - (double)Parallel(&Module::getReceiverProgress, {0}) - .squash(); - printProgress(progress); - break; - } - // otherwise error when connecting to the receiver too fast - std::this_thread::sleep_for(std::chrono::milliseconds(100)); + while (true) { + // to exit acquire by typing q + if (kbhit() != 0) { + if (fgetc(stdin) == 'q') { + LOG(logINFO) << "Caught the command to stop acquisition"; + stopDetector({}); } } + // get and print progress + double temp = + (double)Parallel(&Module::getReceiverProgress, {0}).squash(); + if (temp != progress) { + progress = temp; + printProgress(progress); + } + + // exiting loop + if (getJoinThreadFlag()) { + // print progress one final time before exiting + progress = + (double)Parallel(&Module::getReceiverProgress, {0}).squash(); + printProgress(progress); + break; + } + // otherwise error when connecting to the receiver too fast + std::this_thread::sleep_for(std::chrono::milliseconds(100)); } } @@ -1644,6 +1644,77 @@ void DetectorImpl::verifyUniqueHost( } } +void DetectorImpl::assertTwoUDPDataInterfaces(const std::string &cmd) const { + // assert globally + auto numInterfaces = + Parallel(&Module::getNumberofUDPInterfacesFromShm, {}) + .tsquash("Inconsistent number of UDP interfaces among modules"); + if (numInterfaces != 2) { + throw RuntimeError( + "Cannot " + cmd + + ". Change number of udp interfaces to 2 (cmd = numinterfaces)."); + } +} + +Result DetectorImpl::getUDPDataStream(const defs::portPosition port, + Positions pos) const { + assertTwoUDPDataInterfaces("get enable/disable UDP ports"); + return Parallel(&Module::getUDPDataStream, pos, port); +} + +void DetectorImpl::setUDPDataStream(const defs::portPosition port, + const bool enable, Positions pos) { + assertTwoUDPDataInterfaces("set enable/disable UDP ports"); + Parallel(&Module::setUDPDataStream, pos, port, enable); + updateRxUDPDatastreamMetadata(); +} + +void DetectorImpl::updateRxUDPDatastreamMetadata() { + assertTwoUDPDataInterfaces( + "update Disbaled UDP ports metadata in receiver"); + + std::vector disable; + auto portList = getPortPositionList(); + if (portList.size() != 2) { + throw RuntimeError("Invalid port size. Expected 2."); + } + // bottom and left is port 0 + auto port0 = Parallel(&Module::getUDPDataStream, {}, portList[0]); + auto port1 = Parallel(&Module::getUDPDataStream, {}, portList[1]); + + // if any of them are disabled + if (port0.any(false) || port1.any(false)) { + // for each module: if disabled, push port index + for (size_t i = 0; i != port0.size(); ++i) { + if (!port0[i]) { + disable.push_back(i * 2); + } + if (!port1[i]) { + disable.push_back(i * 2 + 1); + } + } + } + + modules[0]->updateRxUDPPortDisableMetadata(disable); +} + +std::vector DetectorImpl::getRxDisabledUDPPortIndices() const { + assertTwoUDPDataInterfaces("get Disbaled UDP ports metadata from receiver"); + return modules[0]->getRxUDPPortDisableMetadata(); +} + +std::vector DetectorImpl::getPortPositionList() const { + switch (shm()->detType) { + case defs::JUNGFRAU: + case defs::MOENCH: + return std::vector{defs::BOTTOM, defs::TOP}; + case defs::EIGER: + return std::vector{defs::LEFT, defs::RIGHT}; + default: + throw RuntimeError("port Position does not exist for this detector"); + } +} + std::vector DetectorImpl::getRxROI(int module_id) const { if (shm()->detType == CHIPTESTBOARD || shm()->detType == defs::XILINX_CHIPTESTBOARD) { diff --git a/slsDetectorSoftware/src/DetectorImpl.h b/slsDetectorSoftware/src/DetectorImpl.h index d7fcc655d..b29dd7716 100644 --- a/slsDetectorSoftware/src/DetectorImpl.h +++ b/slsDetectorSoftware/src/DetectorImpl.h @@ -3,8 +3,8 @@ #pragma once #include "CtbConfig.h" -#include "SharedMemory.h" #include "sls/Result.h" +#include "sls/SharedMemory.h" #include "sls/ZmqSocket.h" #include "sls/logger.h" #include "sls/sls_detector_defs.h" @@ -278,10 +278,9 @@ class DetectorImpl : public virtual slsDetectorDefs { void stopDetector(Positions pos); /** - * Combines data from all readouts and gives it to the gui - * or just gives progress of acquisition by polling receivers + * gives progress of acquisition by polling receivers */ - void processData(bool receiver); + void printRxProgress(); /** * Convert raw file @@ -310,6 +309,15 @@ class DetectorImpl : public virtual slsDetectorDefs { std::vector> verifyUniqueRxHost(const std::vector &names) const; + void assertTwoUDPDataInterfaces(const std::string &cmd) const; + Result getUDPDataStream(const defs::portPosition port, + Positions pos) const; + void setUDPDataStream(const defs::portPosition port, const bool enable, + Positions pos); + void updateRxUDPDatastreamMetadata(); + std::vector getRxDisabledUDPPortIndices() const; + std::vector getPortPositionList() const; + defs::xy getPortGeometry() const; std::vector getRxROI(int module_id = -1) const; void setRxROI(const std::vector &args); @@ -441,7 +449,8 @@ class DetectorImpl : public virtual slsDetectorDefs { void printProgress(double progress); - void startProcessingThread(bool receiver); + void startRxZmqProcessingThread(); + void startRxProgressThread(); /** * Check if processing thread is ready to join main thread diff --git a/slsDetectorSoftware/src/Module.cpp b/slsDetectorSoftware/src/Module.cpp index ecf9a4db0..64be1d6e7 100644 --- a/slsDetectorSoftware/src/Module.cpp +++ b/slsDetectorSoftware/src/Module.cpp @@ -1,8 +1,8 @@ // SPDX-License-Identifier: LGPL-3.0-or-other // Copyright (C) 2021 Contributors to the SLS Detector Package #include "Module.h" -#include "SharedMemory.h" #include "sls/ClientSocket.h" +#include "sls/SharedMemory.h" #include "sls/ToString.h" #include "sls/Version.h" #include "sls/bit_utils.h" @@ -1407,6 +1407,76 @@ void Module::setTransmissionDelayRight(int value) { sendToDetector(F_SET_TRANSMISSION_DELAY_RIGHT, value, nullptr); } +bool Module::getUDPDataStream(const portPosition port) const { + // receiver only + if (shm()->detType == JUNGFRAU || shm()->detType == MOENCH) { + if (!shm()->useReceiverFlag) { + throw RuntimeError("No receiver to get udp datastream."); + } + return sendToReceiver(F_RECEIVER_GET_UDP_DATASTREAM, + static_cast(port)); + } else + return sendToDetector(F_GET_DATASTREAM, static_cast(port)); +} + +void Module::setUDPDataStream(const portPosition port, const bool enable) { + int args[]{static_cast(port), static_cast(enable)}; + if (shm()->detType == JUNGFRAU || shm()->detType == MOENCH) { + if (!shm()->useReceiverFlag) { + throw RuntimeError("No receiver to set udp datastream."); + } + sendToReceiver(F_RECEIVER_SET_UDP_DATASTREAM, args, nullptr); + } else { + sendToDetector(F_SET_DATASTREAM, args, nullptr); + if (shm()->useReceiverFlag) { + sendToReceiver(F_RECEIVER_SET_UDP_DATASTREAM, args, nullptr); + } + } +} + +void Module::updateRxUDPPortDisableMetadata(const std::vector &disable) { + if (!shm()->useReceiverFlag) { + return; + } + LOG(logDEBUG) << "Updating UDP port disable metadata in Receiver 0"; + auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort); + + client.Send(F_RECEIVER_SET_UDP_PORT_DISABLE_META); + client.setFnum(F_RECEIVER_SET_UDP_PORT_DISABLE_META); + + auto nports = static_cast(disable.size()); + client.Send(nports); + if (nports > 0) { + client.Send(disable); + } + if (client.Receive() == FAIL) { + throw ReceiverError("Receiver " + std::to_string(moduleIndex) + + " returned error: " + client.readErrorMessage()); + } +} + +std::vector Module::getRxUDPPortDisableMetadata() const { + if (!shm()->useReceiverFlag) { + throw RuntimeError("No receiver to get disabled udp port indices."); + } + + LOG(logDEBUG) << "Getting UDP port disable metadata in Receiver 0"; + auto client = ReceiverSocket(shm()->rxHostname, shm()->rxTCPPort); + + client.Send(F_RECEIVER_GET_UDP_PORT_DISABLE_META); + client.setFnum(F_RECEIVER_GET_UDP_PORT_DISABLE_META); + if (client.Receive() == FAIL) { + throw ReceiverError("Receiver " + std::to_string(moduleIndex) + + " returned error: " + client.readErrorMessage()); + } + auto nports = client.Receive(); + std::vector retval(nports); + if (nports > 0) { + client.Receive(retval); + } + return retval; +} + // Receiver Config bool Module::getUseReceiverFlag() const { return shm()->useReceiverFlag; } @@ -1948,18 +2018,6 @@ void Module::setQuad(const bool enable) { } } -bool Module::getDataStream(const portPosition port) const { - return sendToDetector(F_GET_DATASTREAM, static_cast(port)); -} - -void Module::setDataStream(const portPosition port, const bool enable) { - int args[]{static_cast(port), static_cast(enable)}; - sendToDetector(F_SET_DATASTREAM, args, nullptr); - if (shm()->useReceiverFlag) { - sendToReceiver(F_RECEIVER_SET_DATASTREAM, args, nullptr); - } -} - bool Module::getTop() const { return (static_cast(sendToDetector(F_GET_TOP))); } diff --git a/slsDetectorSoftware/src/Module.h b/slsDetectorSoftware/src/Module.h index 55fd6c0b9..1f5097530 100644 --- a/slsDetectorSoftware/src/Module.h +++ b/slsDetectorSoftware/src/Module.h @@ -1,9 +1,9 @@ // SPDX-License-Identifier: LGPL-3.0-or-other // Copyright (C) 2021 Contributors to the SLS Detector Package #pragma once -#include "SharedMemory.h" #include "sls/ClientSocket.h" #include "sls/Pattern.h" +#include "sls/SharedMemory.h" #include "sls/StaticVector.h" #include "sls/bit_utils.h" #include "sls/logger.h" @@ -279,6 +279,10 @@ class Module : public virtual slsDetectorDefs { void setTransmissionDelayLeft(int value); int getTransmissionDelayRight() const; void setTransmissionDelayRight(int value); + bool getUDPDataStream(const portPosition port) const; + void setUDPDataStream(const portPosition port, const bool enable); + void updateRxUDPPortDisableMetadata(const std::vector &disable); + std::vector getRxUDPPortDisableMetadata() const; /************************************************** * * @@ -388,8 +392,6 @@ class Module : public virtual slsDetectorDefs { void pulseChip(int n_pulses = 0); bool getQuad() const; void setQuad(const bool enable); - bool getDataStream(const portPosition port) const; - void setDataStream(const portPosition port, const bool enable); bool getTop() const; void setTop(bool value); diff --git a/slsDetectorSoftware/src/inferAction.cpp b/slsDetectorSoftware/src/inferAction.cpp index d3c8cd23d..9e33d9abb 100644 --- a/slsDetectorSoftware/src/inferAction.cpp +++ b/slsDetectorSoftware/src/inferAction.cpp @@ -694,22 +694,6 @@ int InferAction::dacvalues() { } } -int InferAction::datastream() { - - if (args.size() == 1) { - return slsDetectorDefs::GET_ACTION; - } - - if (args.size() == 2) { - return slsDetectorDefs::PUT_ACTION; - } - - else { - - throw RuntimeError("Could not infer action: Wrong number of arguments"); - } -} - int InferAction::dbitclk() { if (args.size() == 0) { @@ -4025,6 +4009,22 @@ int InferAction::udp_cleardst() { } } +int InferAction::udp_datastream() { + + if (args.size() == 1) { + return slsDetectorDefs::GET_ACTION; + } + + if (args.size() == 2) { + return slsDetectorDefs::PUT_ACTION; + } + + else { + + throw RuntimeError("Could not infer action: Wrong number of arguments"); + } +} + int InferAction::udp_dstip() { if (args.size() == 0) { diff --git a/slsDetectorSoftware/src/inferAction.h b/slsDetectorSoftware/src/inferAction.h index 6baa59d66..1e3c4f3c3 100644 --- a/slsDetectorSoftware/src/inferAction.h +++ b/slsDetectorSoftware/src/inferAction.h @@ -56,7 +56,6 @@ class InferAction { int daclist(); int dacname(); int dacvalues(); - int datastream(); int dbitclk(); int dbitphase(); int dbitpipeline(); @@ -296,6 +295,7 @@ class InferAction { int txdelay_right(); int type(); int udp_cleardst(); + int udp_datastream(); int udp_dstip(); int udp_dstip2(); int udp_dstlist(); @@ -390,7 +390,6 @@ class InferAction { {"daclist", &InferAction::daclist}, {"dacname", &InferAction::dacname}, {"dacvalues", &InferAction::dacvalues}, - {"datastream", &InferAction::datastream}, {"dbitclk", &InferAction::dbitclk}, {"dbitphase", &InferAction::dbitphase}, {"dbitpipeline", &InferAction::dbitpipeline}, @@ -634,6 +633,7 @@ class InferAction { {"txdelay_right", &InferAction::txdelay_right}, {"type", &InferAction::type}, {"udp_cleardst", &InferAction::udp_cleardst}, + {"udp_datastream", &InferAction::udp_datastream}, {"udp_dstip", &InferAction::udp_dstip}, {"udp_dstip2", &InferAction::udp_dstip2}, {"udp_dstlist", &InferAction::udp_dstlist}, diff --git a/slsDetectorSoftware/tests/CMakeLists.txt b/slsDetectorSoftware/tests/CMakeLists.txt index e39ce339b..029c98e8f 100755 --- a/slsDetectorSoftware/tests/CMakeLists.txt +++ b/slsDetectorSoftware/tests/CMakeLists.txt @@ -6,6 +6,7 @@ target_sources(tests PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/test-SharedMemory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/acquire/Acquire.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/acquire/CTBState.cpp ${CMAKE_CURRENT_SOURCE_DIR}/acquire/ExpectedState.cpp ${CMAKE_CURRENT_SOURCE_DIR}/Caller/test-Caller.cpp diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp index 5c91a50fe..f325d0edd 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-eiger.cpp @@ -589,46 +589,6 @@ TEST_CASE("quad", "[.detectorintegration]") { } } -TEST_CASE("datastream", "[.detectorintegration]") { - Detector det; - Caller caller(&det); - auto det_type = det.getDetectorType().squash(); - if (det_type == defs::EIGER) { - auto prev_val_left = det.getDataStream(defs::LEFT); - auto prev_val_right = det.getDataStream(defs::RIGHT); - // no "left" or "right" - REQUIRE_THROWS(caller.call("datastream", {"1"}, -1, PUT)); - { - std::ostringstream oss; - caller.call("datastream", {"left", "0"}, -1, PUT, oss); - REQUIRE(oss.str() == "datastream [left, 0]\n"); - } - { - std::ostringstream oss; - caller.call("datastream", {"right", "0"}, -1, PUT, oss); - REQUIRE(oss.str() == "datastream [right, 0]\n"); - } - { - std::ostringstream oss; - caller.call("datastream", {"left", "1"}, -1, PUT, oss); - REQUIRE(oss.str() == "datastream [left, 1]\n"); - } - { - std::ostringstream oss; - caller.call("datastream", {"right", "1"}, -1, PUT, oss); - REQUIRE(oss.str() == "datastream [right, 1]\n"); - } - for (int i = 0; i != det.size(); ++i) { - det.setDataStream(defs::LEFT, prev_val_left[i], {i}); - det.setDataStream(defs::RIGHT, prev_val_right[i], {i}); - } - } else { - REQUIRE_THROWS(caller.call("datastream", {}, -1, GET)); - REQUIRE_THROWS(caller.call("datastream", {"1"}, -1, PUT)); - REQUIRE_THROWS(caller.call("datastream", {"left", "1"}, -1, PUT)); - } -} - TEST_CASE("top", "[.detectorintegration]") { Detector det; Caller caller(&det); diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-global.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-global.cpp index 5b4ba685f..f2204d154 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-global.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-global.cpp @@ -99,31 +99,4 @@ void test_onchip_dac_caller(defs::dacIndex index, const std::string &dacname, } } -std::pair -calculate_ctb_image_size(const acq::CTBState &test_info, bool isXilinxCtb) { - - LOG(logDEBUG1) << test_info; - sls::CtbImageInputs inputs{}; - inputs.mode = test_info.readout_mode; - inputs.nAnalogSamples = test_info.num_adc_samples; - inputs.adcMask = test_info.adc_enable_10g; - if (!isXilinxCtb && !test_info.ten_giga) { - inputs.adcMask = test_info.adc_enable_1g; - } - inputs.nTransceiverSamples = test_info.num_trans_samples; - inputs.transceiverMask = test_info.transceiver_mask; - inputs.nDigitalSamples = test_info.num_dbit_samples; - inputs.dbitOffset = test_info.dbit_offset; - inputs.dbitReorder = test_info.dbit_reorder; - inputs.dbitList = test_info.dbit_list; - - auto out = computeCtbImageSize(inputs); - uint64_t image_size = - out.nAnalogBytes + out.nDigitalBytes + out.nTransceiverBytes; - LOG(logDEBUG1) << "Expected image size: " << image_size; - int npixelx = out.nPixelsX; - LOG(logDEBUG1) << "Expected number of pixels in x: " << npixelx; - return std::make_pair(image_size, npixelx); -} - } // namespace sls diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-global.h b/slsDetectorSoftware/tests/Caller/test-Caller-global.h index 47e3d7c19..c3b35766f 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-global.h +++ b/slsDetectorSoftware/tests/Caller/test-Caller-global.h @@ -2,7 +2,7 @@ // Copyright (C) 2021 Contributors to the SLS Detector Package #pragma once -#include "acquire/CTBState.h" +#include "checks/MasterFileChecks.h" #include "sls/sls_detector_defs.h" #include @@ -13,6 +13,8 @@ namespace sls { namespace acq = sls::test::acquire; +namespace mf = sls::test::master_file; +namespace checks = sls::test::checks; void test_valid_port_caller(const std::string &command, const std::vector &arguments, @@ -23,7 +25,42 @@ void test_dac_caller(slsDetectorDefs::dacIndex index, void test_onchip_dac_caller(slsDetectorDefs::dacIndex index, const std::string &dacname, int dacvalue); -std::pair -calculate_ctb_image_size(const acq::CTBState &test_info, bool isXilinxCtb); +/** + * Helper function to run an acquisition and check the master file (both binary + * and hdf5) for expected values. The function takes in a lambda that is called + * with the master filechecker object to perform checks on the master file. The + * acquisition is run with default acquisition and file states, but these can be + * modified within the lambda if needed. This version has the master file + * checker object created within the function instead of using a helper + * function, to allow for more flexibility in handling exceptions (especially + * HDF5 exceptions) and logging. + */ +template +void test_run_with_master_file_checker(Detector &det, F f) { + + auto acq_state = acq::default_acquisition_state(); + auto file_state = acq::default_file_state(); + std::array formats = {defs::BINARY, defs::HDF5}; + + for (const auto &format : formats) { + file_state.file_format = format; + acq::run(det, acq_state, file_state); + std::string fname = acq::get_master_file_name(file_state); + if (format == defs::HDF5) { +#ifdef HDF5C + try { + mf::Checker checker(fname); + f(det, acq_state, file_state, checker); + } catch (H5::Exception &e) { + LOG(logERROR) << "HDF5 error: " << e.getDetailMsg(); + throw; + } +#endif + } else { + mf::Checker checker(fname); + f(det, acq_state, file_state, checker); + } + } +} } // namespace sls diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp index 5a3933ea8..a4661f62a 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-master-attributes.cpp @@ -1,29 +1,15 @@ // SPDX-License-Identifier: LGPL-3.0-or-other // Copyright (C) 2021 Contributors to the SLS Detector Package -#include "acquire/ExpectedState.h" -#include "checks/MasterFileChecks.h" - #include "sls/Detector.h" #include "sls/ToString.h" -#include "sls/logger.h" +#include "test-Caller-global.h" #include "catch.hpp" -#include -#include -#include -#include -#include #include -#ifdef HDF5C -#include "H5Cpp.h" -#endif - namespace sls { -namespace mf = sls::test::master_file; namespace acq = sls::test::acquire; -namespace checks = sls::test::checks; TEST_CASE("check_master_file_attributes", "[.detectorintegration][.disable_check_data_file]") { @@ -32,10 +18,6 @@ TEST_CASE("check_master_file_attributes", auto detType = det.getDetectorType().squash(defs::GENERIC); INFO("Testing master file attributes with " << ToString(detType)); - // currently num frame = 1 (default) - auto acq_state = acq::default_acquisition_state(); - auto file_state = acq::default_file_state(); - // if ctb, set to default and restore after test std::optional ctb_state = std::nullopt; if (detType == defs::CHIPTESTBOARD || @@ -44,36 +26,75 @@ TEST_CASE("check_master_file_attributes", } acq::CTBStateGuard ctb_guard(det, ctb_state); - // binary => /tmp/sls_test_master_0.json - file_state.file_format = defs::BINARY; - acq::run(det, acq_state, file_state); + test_run_with_master_file_checker( + det, [&](auto &det, auto &acq_state, auto &file_state, auto &checker) { + // get expected state of parameters and check against master file + auto expected_state = acq::build_expected_state( + det, acq_state, file_state, ctb_state); + checks::check_metadata(checker, expected_state); + }); +} - std::string fname = acq::get_master_file_name(file_state); - mf::Checker checker(fname); +TEST_CASE("udp_datastream with master file", + "[.detectorintegration][.disable_check_data_file]") { + Detector det; + auto det_type = det.getDetectorType().squash(); + if (det_type == defs::EIGER) { + auto prev_val_left = det.getUDPDataStream(defs::LEFT); + auto prev_val_right = det.getUDPDataStream(defs::RIGHT); - // get expected state of parameters and check against master file - acq::ExpectedState expected_state = - acq::build_expected_state(det, acq_state, file_state, ctb_state); - checks::check_metadata(checker, expected_state); + det.setUDPDataStream(defs::LEFT, false); + // check master file + { + // expected + std::vector expected_ports = + det.getPortPositionList(); + std::vector expected_disabled_ports = + det.getRxDisabledUDPPortIndices(); + REQUIRE(expected_disabled_ports.size() > 0); -#ifdef HDF5C - try { - // hdf5 => /tmp/sls_test_master_0.h5 - file_state.file_format = defs::HDF5; - acq::run(det, acq_state, file_state); + test_run_with_master_file_checker( + det, [&](auto &det, auto &acq_state, auto &file_state, + auto &checker) { + checks::check_udp_ports_type(checker, expected_ports); + checks::check_udp_ports_disabled(checker, + expected_disabled_ports); + }); + } - std::string fname = acq::get_master_file_name(file_state); - mf::Checker checker(fname); + for (int i = 0; i != det.size(); ++i) { + det.setUDPDataStream(defs::LEFT, prev_val_left[i], {i}); + det.setUDPDataStream(defs::RIGHT, prev_val_right[i], {i}); + } + } else if ((det_type == defs::JUNGFRAU || det_type == defs::MOENCH) && + (det.getNumberofUDPInterfaces().squash(0) == 2)) { + auto prev_val_top = det.getUDPDataStream(defs::TOP); + auto prev_val_bottom = det.getUDPDataStream(defs::BOTTOM); - // get expected state of parameters and check against master file - acq::ExpectedState expected_state = - acq::build_expected_state(det, acq_state, file_state, ctb_state); - checks::check_metadata(checker, expected_state); - } catch (H5::Exception &e) { - LOG(logERROR) << "HDF5 error: " << e.getDetailMsg(); - throw; + det.setUDPDataStream(defs::TOP, false); + // check master file + { + // expected + std::vector expected_ports = + det.getPortPositionList(); + std::vector expected_disabled_ports = + det.getRxDisabledUDPPortIndices(); + REQUIRE(expected_disabled_ports.size() > 0); + + test_run_with_master_file_checker( + det, [&](auto &det, auto &acq_state, auto &file_state, + auto &checker) { + checks::check_udp_ports_type(checker, expected_ports); + checks::check_udp_ports_disabled(checker, + expected_disabled_ports); + }); + } + + for (int i = 0; i != det.size(); ++i) { + det.setUDPDataStream(defs::TOP, prev_val_top[i], {i}); + det.setUDPDataStream(defs::BOTTOM, prev_val_bottom[i], {i}); + } } -#endif } } // namespace sls diff --git a/slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp b/slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp index 2e8d8a9bd..80d7e322d 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller-rx.cpp @@ -127,7 +127,8 @@ TEST_CASE("rx_framescaught", "[.detectorintegration]") { } } -TEST_CASE("rx_missingpackets", "[.detectorintegration]") { +TEST_CASE("rx_missingpackets", + "[.detectorintegration][.disable_check_data_file]") { Detector det; Caller caller(&det); auto prev_val = det.getFileWrite(); diff --git a/slsDetectorSoftware/tests/Caller/test-Caller.cpp b/slsDetectorSoftware/tests/Caller/test-Caller.cpp index 150548f4b..77a1bd240 100644 --- a/slsDetectorSoftware/tests/Caller/test-Caller.cpp +++ b/slsDetectorSoftware/tests/Caller/test-Caller.cpp @@ -3068,6 +3068,95 @@ TEST_CASE("txdelay", "[.detectorintegration]") { } } +TEST_CASE("udp_datastream", "[.detectorintegration]") { + Detector det; + Caller caller(&det); + auto det_type = det.getDetectorType().squash(); + if (det_type == defs::EIGER) { + auto prev_val_left = det.getUDPDataStream(defs::LEFT); + auto prev_val_right = det.getUDPDataStream(defs::RIGHT); + + // invalid args + REQUIRE_THROWS(caller.call("udp_datastream", {"top", "1"}, -1, PUT)); + REQUIRE_THROWS(caller.call("udp_datastream", {"bottom", "1"}, -1, PUT)); + // no "left" or "right" argument + REQUIRE_THROWS(caller.call("udp_datastream", {"1"}, -1, PUT)); + { + std::ostringstream oss; + caller.call("udp_datastream", {"left", "0"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [left, 0]\n"); + } + { + std::ostringstream oss; + caller.call("udp_datastream", {"right", "0"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [right, 0]\n"); + } + { + std::ostringstream oss; + caller.call("udp_datastream", {"left", "1"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [left, 1]\n"); + } + { + std::ostringstream oss; + caller.call("udp_datastream", {"right", "1"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [right, 1]\n"); + } + for (int i = 0; i != det.size(); ++i) { + det.setUDPDataStream(defs::LEFT, prev_val_left[i], {i}); + det.setUDPDataStream(defs::RIGHT, prev_val_right[i], {i}); + } + } else if (det_type == defs::JUNGFRAU || det_type == defs::MOENCH) { + + // throw with 1 interface + if (det.getNumberofUDPInterfaces().squash() == 1) { + REQUIRE_THROWS( + caller.call("udp_datastream", {"top", "0"}, -1, PUT)); + } + // 2 interfaces + else { + auto prev_val_top = det.getUDPDataStream(defs::TOP); + auto prev_val_bottom = det.getUDPDataStream(defs::BOTTOM); + + // invalid args + REQUIRE_THROWS( + caller.call("udp_datastream", {"left", "1"}, -1, PUT)); + REQUIRE_THROWS( + caller.call("udp_datastream", {"right", "1"}, -1, PUT)); + // no "top" or "bottom" argument + REQUIRE_THROWS(caller.call("udp_datastream", {"1"}, -1, PUT)); + { + std::ostringstream oss; + caller.call("udp_datastream", {"top", "0"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [top, 0]\n"); + } + { + std::ostringstream oss; + caller.call("udp_datastream", {"bottom", "0"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [bottom, 0]\n"); + } + { + std::ostringstream oss; + caller.call("udp_datastream", {"top", "1"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [top, 1]\n"); + } + { + std::ostringstream oss; + caller.call("udp_datastream", {"bottom", "1"}, -1, PUT, oss); + REQUIRE(oss.str() == "udp_datastream [bottom, 1]\n"); + } + for (int i = 0; i != det.size(); ++i) { + det.setUDPDataStream(defs::TOP, prev_val_top[i], {i}); + det.setUDPDataStream(defs::BOTTOM, prev_val_bottom[i], {i}); + } + } + } else { + REQUIRE_THROWS(caller.call("udp_datastream", {}, -1, GET)); + REQUIRE_THROWS(caller.call("udp_datastream", {"1"}, -1, PUT)); + REQUIRE_THROWS(caller.call("udp_datastream", {"left", "1"}, -1, PUT)); + REQUIRE_THROWS(caller.call("udp_datastream", {"top", "1"}, -1, PUT)); + } +} + /* ZMQ Streaming Parameters (Receiver<->Client) */ TEST_CASE("zmqport", "[.detectorintegration]") { diff --git a/slsDetectorSoftware/tests/acquire/CTBState.cpp b/slsDetectorSoftware/tests/acquire/CTBState.cpp new file mode 100644 index 000000000..ac5e5bd81 --- /dev/null +++ b/slsDetectorSoftware/tests/acquire/CTBState.cpp @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: LGPL-3.0-or-other +// Copyright (C) 2021 Contributors to the SLS Detector Package + +#include "CTBState.h" +#include "GeneralData.h" + +namespace sls::test::acquire { + +std::pair calculate_ctb_image_size(const CTBState &test_info, + bool isXilinxCtb) { + LOG(logDEBUG1) << test_info; + CtbImageInputs inputs{}; + inputs.mode = test_info.readout_mode; + inputs.nAnalogSamples = test_info.num_adc_samples; + inputs.adcMask = test_info.adc_enable_10g; + if (!isXilinxCtb && !test_info.ten_giga) { + inputs.adcMask = test_info.adc_enable_1g; + } + inputs.nTransceiverSamples = test_info.num_trans_samples; + inputs.transceiverMask = test_info.transceiver_mask; + inputs.nDigitalSamples = test_info.num_dbit_samples; + inputs.dbitOffset = test_info.dbit_offset; + inputs.dbitReorder = test_info.dbit_reorder; + inputs.dbitList = test_info.dbit_list; + + auto out = computeCtbImageSize(inputs); + uint64_t image_size = + out.nAnalogBytes + out.nDigitalBytes + out.nTransceiverBytes; + LOG(logDEBUG1) << "Expected image size: " << image_size; + int npixelx = out.nPixelsX; + LOG(logDEBUG1) << "Expected number of pixels in x: " << npixelx; + return std::make_pair(image_size, npixelx); +} + +} // namespace sls::test::acquire \ No newline at end of file diff --git a/slsDetectorSoftware/tests/acquire/CTBState.h b/slsDetectorSoftware/tests/acquire/CTBState.h index dede4d9e4..da5eca98e 100644 --- a/slsDetectorSoftware/tests/acquire/CTBState.h +++ b/slsDetectorSoftware/tests/acquire/CTBState.h @@ -135,4 +135,14 @@ class CTBStateGuard { CTBState saved_; }; +/** + * @brief + * @param test_info current CTB state + * @param isXilinxCtb if the detector type is Xilinx CTB + * @return std::pair pair of image size in bytes and number of + * channels in dimension X (Currently only analog channels) + */ +std::pair calculate_ctb_image_size(const CTBState &test_info, + bool isXilinxCtb); + } // namespace sls::test::acquire \ No newline at end of file diff --git a/slsDetectorSoftware/tests/acquire/ExpectedState.cpp b/slsDetectorSoftware/tests/acquire/ExpectedState.cpp index 17a5edcf0..9dc44ba7c 100644 --- a/slsDetectorSoftware/tests/acquire/ExpectedState.cpp +++ b/slsDetectorSoftware/tests/acquire/ExpectedState.cpp @@ -2,7 +2,6 @@ // Copyright (C) 2021 Contributors to the SLS Detector Package #include "ExpectedState.h" -#include "Caller/test-Caller-global.h" #include "receiver_defs.h" // unnamed namespace for internal linkage @@ -47,7 +46,7 @@ defs::xy get_port_shape(const Detector &det, "CTB state must be provided to calculate expected port shape"); } portSize.x = - sls::calculate_ctb_image_size( + acq::calculate_ctb_image_size( ctb_state.value(), det_type == defs::XILINX_CHIPTESTBOARD) .second; portSize.y = 1; @@ -136,6 +135,14 @@ int get_num_udp_interfaces(const Detector &det) { "Inconsistent number of UDP interfaces"); } +std::vector get_udp_port_types(const Detector &det) { + return det.getPortPositionList(); +} + +std::vector get_udp_ports_disabled(const Detector &det) { + return det.getRxDisabledUDPPortIndices(); +} + int get_read_n_rows(const Detector &det) { return det.getReadNRows().tsquash("Inconsistent number of read rows"); } @@ -184,6 +191,10 @@ acq::JungfrauExpectedState build_jungfrau_specific_state(const Detector &det) { e.exptime = get_exptime(det); e.period = get_period(det); e.num_udp_interfaces = get_num_udp_interfaces(det); + if (e.num_udp_interfaces == 2) { + e.udp_port_types = get_udp_port_types(det); + e.udp_ports_disabled = get_udp_ports_disabled(det); + } e.read_n_rows = get_read_n_rows(det); e.readout_speed = get_readout_speed(det); return e; @@ -195,6 +206,10 @@ acq::MoenchExpectedState build_moench_specific_state(const Detector &det) { e.exptime = get_exptime(det); e.period = get_period(det); e.num_udp_interfaces = get_num_udp_interfaces(det); + if (e.num_udp_interfaces == 2) { + e.udp_port_types = get_udp_port_types(det); + e.udp_ports_disabled = get_udp_ports_disabled(det); + } e.read_n_rows = get_read_n_rows(det); e.readout_speed = get_readout_speed(det); return e; @@ -213,6 +228,8 @@ acq::EigerExpectedState build_eiger_specific_state(const Detector &det) { e.sub_exptime = sub_exptime; e.sub_period = sub_period; e.quad = det.getQuad().tsquash("Inconsistent quad setting"); + e.udp_port_types = get_udp_port_types(det); + e.udp_ports_disabled = get_udp_ports_disabled(det); e.read_n_rows = get_read_n_rows(det); { for (auto item : det.getRateCorrection()) @@ -342,7 +359,7 @@ int get_expected_image_size(const Detector &det, } LOG(logINFORED) << ctb_state.value(); image_size = - sls::calculate_ctb_image_size( + acq::calculate_ctb_image_size( ctb_state.value(), (det_type == defs::XILINX_CHIPTESTBOARD)) .first; break; diff --git a/slsDetectorSoftware/tests/acquire/ExpectedState.h b/slsDetectorSoftware/tests/acquire/ExpectedState.h index 06b457cef..bff309485 100644 --- a/slsDetectorSoftware/tests/acquire/ExpectedState.h +++ b/slsDetectorSoftware/tests/acquire/ExpectedState.h @@ -31,6 +31,8 @@ struct JungfrauExpectedState { ns exptime{}; ns period{}; int num_udp_interfaces{}; + std::vector udp_port_types; + std::vector udp_ports_disabled; int read_n_rows{}; defs::speedLevel readout_speed{}; }; @@ -40,6 +42,8 @@ struct MoenchExpectedState { ns exptime{}; ns period{}; int num_udp_interfaces{}; + std::vector udp_port_types; + std::vector udp_ports_disabled; int read_n_rows{}; defs::speedLevel readout_speed{}; }; @@ -54,6 +58,8 @@ struct EigerExpectedState { ns sub_exptime{}; ns sub_period{}; bool quad{}; + std::vector udp_port_types; + std::vector udp_ports_disabled; int read_n_rows{}; std::vector rate_corrections{}; defs::speedLevel readout_speed{}; diff --git a/slsDetectorSoftware/tests/checks/MasterFileChecks.h b/slsDetectorSoftware/tests/checks/MasterFileChecks.h index db5fff20f..d5770913e 100644 --- a/slsDetectorSoftware/tests/checks/MasterFileChecks.h +++ b/slsDetectorSoftware/tests/checks/MasterFileChecks.h @@ -128,6 +128,22 @@ void check_num_udp_interfaces(CheckerT &checker, const int &value) { value); } +template +void check_udp_ports_type(CheckerT &checker, + const std::vector &value) { + REQUIRE(value.size() == 2); + std::vector ports = {ToString(value[0]), ToString(value[1])}; + checker.template check>( + MasterAttributes::N_UDP_PORTS_TYPE.data(), ports); +} + +template +void check_udp_ports_disabled(CheckerT &checker, + const std::vector &value) { + checker.template check>( + MasterAttributes::N_UDP_PORTS_DISABLED.data(), value); +} + template void check_read_n_rows(CheckerT &checker, const int &value) { checker.template check(MasterAttributes::N_NUMBER_OF_ROWS.data(), @@ -318,6 +334,10 @@ void check_jungfrau_metadata(CheckerT &checker, check_exptime(checker, st.exptime); check_period(checker, st.period); check_num_udp_interfaces(checker, st.num_udp_interfaces); + if (st.num_udp_interfaces == 2) { + check_udp_ports_type(checker, st.udp_port_types); + check_udp_ports_disabled(checker, st.udp_ports_disabled); + } check_read_n_rows(checker, st.read_n_rows); check_readout_speed(checker, st.readout_speed); } @@ -331,6 +351,10 @@ void check_moench_metadata(CheckerT &checker, check_exptime(checker, st.exptime); check_period(checker, st.period); check_num_udp_interfaces(checker, st.num_udp_interfaces); + if (st.num_udp_interfaces == 2) { + check_udp_ports_type(checker, st.udp_port_types); + check_udp_ports_disabled(checker, st.udp_ports_disabled); + } check_read_n_rows(checker, st.read_n_rows); check_readout_speed(checker, st.readout_speed); } @@ -349,6 +373,8 @@ void check_eiger_metadata(CheckerT &checker, check_sub_exptime(checker, st.sub_exptime); check_sub_period(checker, st.sub_period); check_quad(checker, st.quad); + check_udp_ports_type(checker, st.udp_port_types); + check_udp_ports_disabled(checker, st.udp_ports_disabled); check_read_n_rows(checker, st.read_n_rows); check_rate_corrections(checker, st.rate_corrections); check_readout_speed(checker, st.readout_speed); diff --git a/slsDetectorSoftware/tests/master_file/ReadersH5.h b/slsDetectorSoftware/tests/master_file/ReadersH5.h index fcd4fa9f7..699e30529 100644 --- a/slsDetectorSoftware/tests/master_file/ReadersH5.h +++ b/slsDetectorSoftware/tests/master_file/ReadersH5.h @@ -238,6 +238,23 @@ template <> struct Reader> { } }; +template <> struct Reader> { + static std::vector read(const H5Context &ctx, const std::string &name, + AccessType access) { + if (access == AccessType::Attribute) { + throw RuntimeError("'std::vector' attribute access not " + "supported for HDF5"); + } + require_dataset(ctx, name); + auto ds = ctx.file.openDataSet(HDF5_GROUP + name); + auto len = get_1d_size(ds); + std::vector out{}; + out.resize(len); + ds.read(out.data(), H5::PredType::NATIVE_INT); + return out; + } +}; + template <> struct Reader> { static std::vector read(const H5Context &ctx, const std::string &name, AccessType access) { @@ -255,6 +272,29 @@ template <> struct Reader> { } }; +template <> struct Reader> { + static std::vector + read(const H5Context &ctx, const std::string &name, AccessType access) { + if (access == AccessType::Attribute) { + throw RuntimeError( + "'std::vector' attribute access not " + "supported for HDF5"); + } + require_dataset(ctx, name); + auto ds = ctx.file.openDataSet(HDF5_GROUP + name); + H5::StrType strType(H5::PredType::C_S1, H5T_VARIABLE); + std::vector raw; + raw.resize(get_1d_size(ds)); + ds.read(raw.data(), strType); + std::vector out; + out.reserve(raw.size()); + for (auto c : raw) { + out.emplace_back(c); + } + return out; + } +}; + template <> struct Reader> { static std::map read(const H5Context &ctx, const std::string &name, AccessType access) { diff --git a/slsDetectorSoftware/tests/master_file/ReadersJson.h b/slsDetectorSoftware/tests/master_file/ReadersJson.h index 013f8f0fd..4eb8b2a8b 100644 --- a/slsDetectorSoftware/tests/master_file/ReadersJson.h +++ b/slsDetectorSoftware/tests/master_file/ReadersJson.h @@ -120,6 +120,17 @@ template <> struct Reader> { } }; +template <> struct Reader> { + static std::vector read(const JsonContext &ctx, + const std::string &name, AccessType access) { + std::vector out{}; + for (const auto &item : ctx.doc[name.c_str()].GetArray()) { + out.push_back(item.GetInt()); + } + return out; + } +}; + template <> struct Reader> { static std::vector read(const JsonContext &ctx, const std::string &name, AccessType access) { @@ -131,6 +142,17 @@ template <> struct Reader> { } }; +template <> struct Reader> { + static std::vector + read(const JsonContext &ctx, const std::string &name, AccessType access) { + std::vector out{}; + for (const auto &item : ctx.doc[name.c_str()].GetArray()) { + out.push_back(item.GetString()); + } + return out; + } +}; + template <> struct Reader> { static std::map read(const JsonContext &ctx, const std::string &name, AccessType access) { diff --git a/slsDetectorSoftware/tests/test-CtbConfig.cpp b/slsDetectorSoftware/tests/test-CtbConfig.cpp index 5aaffeb3e..84c904c5e 100644 --- a/slsDetectorSoftware/tests/test-CtbConfig.cpp +++ b/slsDetectorSoftware/tests/test-CtbConfig.cpp @@ -4,7 +4,7 @@ #include #include "CtbConfig.h" -#include "SharedMemory.h" +#include "sls/SharedMemory.h" #include #include diff --git a/slsDetectorSoftware/tests/test-Module.cpp b/slsDetectorSoftware/tests/test-Module.cpp index 39d9ef568..779f3ea34 100644 --- a/slsDetectorSoftware/tests/test-Module.cpp +++ b/slsDetectorSoftware/tests/test-Module.cpp @@ -2,8 +2,8 @@ // Copyright (C) 2021 Contributors to the SLS Detector Package #include "Detector.h" #include "Module.h" -#include "SharedMemory.h" #include "catch.hpp" +#include "sls/SharedMemory.h" namespace sls { diff --git a/slsDetectorSoftware/tests/test-SharedMemory.cpp b/slsDetectorSoftware/tests/test-SharedMemory.cpp index d8a1efb16..324205acf 100644 --- a/slsDetectorSoftware/tests/test-SharedMemory.cpp +++ b/slsDetectorSoftware/tests/test-SharedMemory.cpp @@ -2,8 +2,8 @@ // Copyright (C) 2021 Contributors to the SLS Detector Package #define DISABLE_STATIC_ASSERT // to be able to test obsolete shm without isValid -#include "SharedMemory.h" #include "catch.hpp" +#include "sls/SharedMemory.h" #include "sls/string_utils.h" #include diff --git a/slsReceiverSoftware/src/ClientInterface.cpp b/slsReceiverSoftware/src/ClientInterface.cpp index 9ce6b22be..4b14004c7 100644 --- a/slsReceiverSoftware/src/ClientInterface.cpp +++ b/slsReceiverSoftware/src/ClientInterface.cpp @@ -207,7 +207,7 @@ int ClientInterface::functionTable(){ flist[F_GET_RECEIVER_STREAMING_HWM] = &ClientInterface::get_streaming_hwm; flist[F_SET_RECEIVER_STREAMING_HWM] = &ClientInterface::set_streaming_hwm; flist[F_RECEIVER_SET_ALL_THRESHOLD] = &ClientInterface::set_all_threshold; - flist[F_RECEIVER_SET_DATASTREAM] = &ClientInterface::set_detector_datastream; + flist[F_RECEIVER_SET_UDP_DATASTREAM] = &ClientInterface::set_port_udp_datastream; flist[F_GET_RECEIVER_ARPING] = &ClientInterface::get_arping; flist[F_SET_RECEIVER_ARPING] = &ClientInterface::set_arping; flist[F_RECEIVER_GET_RECEIVER_ROI] = &ClientInterface::get_receiver_roi; @@ -221,6 +221,10 @@ int ClientInterface::functionTable(){ flist[F_SET_RECEIVER_DBIT_REORDER] = &ClientInterface::set_dbit_reorder; flist[F_RECEIVER_GET_ROI_METADATA] = &ClientInterface::get_roi_metadata; flist[F_SET_RECEIVER_READOUT_SPEED] = &ClientInterface::set_readout_speed; + flist[F_RECEIVER_GET_UDP_DATASTREAM] = &ClientInterface::get_port_udp_datastream; + flist[F_RECEIVER_SET_UDP_PORT_DISABLE_META] = &ClientInterface::set_udp_port_disable_meta; + flist[F_RECEIVER_GET_UDP_PORT_DISABLE_META] = &ClientInterface::get_udp_port_disable_meta; + for (int i = NUM_DET_FUNCTIONS + 1; i < NUM_REC_FUNCTIONS ; i++) { LOG(logDEBUG1) << "function fnum: " << i << " (" << @@ -383,8 +387,8 @@ int ClientInterface::setup_receiver(Interface &socket) { impl()->setSubPeriod(std::chrono::nanoseconds(arg.subExpTimeNs) + std::chrono::nanoseconds(arg.subDeadTimeNs)); impl()->setActivate(static_cast(arg.activate)); - impl()->setDetectorDataStream(LEFT, arg.dataStreamLeft); - impl()->setDetectorDataStream(RIGHT, arg.dataStreamRight); + impl()->setUDPDataStream(LEFT, arg.dataStreamLeft); + impl()->setUDPDataStream(RIGHT, arg.dataStreamRight); impl()->setQuad(arg.quad == 0 ? false : true); impl()->setThresholdEnergy(arg.thresholdEnergyeV[0]); } @@ -398,7 +402,7 @@ int ClientInterface::setup_receiver(Interface &socket) { } impl()->setThresholdEnergy(val); } - if (detType == EIGER || detType == MYTHEN3) { + if (detType == EIGER || detType == MYTHEN3 || detType == MATTERHORN) { impl()->setDynamicRange(arg.dynamicRange); } impl()->setTimingMode(arg.timMode); @@ -429,6 +433,10 @@ int ClientInterface::setup_receiver(Interface &socket) { impl()->setGateDelay3(std::chrono::nanoseconds(arg.gateDelay3Ns)); impl()->setNumberOfGates(arg.gates); } + if (detType == MATTERHORN) { + impl()->setCounterMask(arg.countermask); + } + LOG(logDEBUG) << "set counter mask to " << arg.countermask; if (detType == GOTTHARD2) { impl()->setBurstMode(arg.burstType); } @@ -450,6 +458,7 @@ void ClientInterface::setDetectorType(detectorType arg) { case MOENCH: case MYTHEN3: case GOTTHARD2: + case MATTERHORN: break; default: throw RuntimeError("Unknown detector type: " + std::to_string(arg)); @@ -666,12 +675,21 @@ int ClientInterface::set_dynamic_range(Interface &socket) { break; */ case 4: + if (detType == MATTERHORN || detType == EIGER) { + exists = true; + } + break; case 12: if (detType == EIGER) { exists = true; } break; case 8: + if (detType == MATTERHORN || detType == EIGER || + detType == MYTHEN3) { + exists = true; + } + break; case 32: if (detType == EIGER || detType == MYTHEN3) { exists = true; @@ -1653,27 +1671,58 @@ int ClientInterface::set_all_threshold(Interface &socket) { return socket.Send(OK); } -int ClientInterface::set_detector_datastream(Interface &socket) { - int args[2]{-1, -1}; - socket.Receive(args); - portPosition port = static_cast(args[0]); +void ClientInterface::validate_port_position(const portPosition port) { + bool exists = false; switch (port) { case LEFT: case RIGHT: + if (detType == EIGER) { + exists = true; + } + break; + case TOP: + case BOTTOM: + if (detType == JUNGFRAU || detType == MOENCH) { + exists = true; + } break; default: throw RuntimeError("Invalid port type"); } - bool enable = static_cast(args[1]); - LOG(logDEBUG1) << "Setting datastream (" << ToString(port) << ") to " - << ToString(enable); - if (detType != EIGER) + if (!exists) { + modeNotImplemented("Port type", port); + } +} + +int ClientInterface::set_port_udp_datastream(Interface &socket) { + if (detType != EIGER && detType != JUNGFRAU && detType != MOENCH) functionNotImplemented(); + int args[2]{-1, -1}; + socket.Receive(args); + portPosition port = static_cast(args[0]); + validate_port_position(port); + bool enable = static_cast(args[1]); + if (impl()->getNumberofUDPInterfaces() == 1) + throw RuntimeError("Cannot change UDP port datastream with only 1 " + "interface enabled. Hint: set 'numinterfaces' to 2"); + LOG(logDEBUG1) << "Setting udp datastream (" << ToString(port) << ") to " + << ToString(enable); verifyIdle(socket); - impl()->setDetectorDataStream(port, enable); + impl()->setUDPDataStream(port, enable); return socket.Send(OK); } +int ClientInterface::get_port_udp_datastream(Interface &socket) { + auto arg = socket.Receive(); + portPosition port = static_cast(arg); + validate_port_position(port); + LOG(logDEBUG1) << "Getting udp datastream (" << ToString(port) << ")"; + if (detType != EIGER && detType != JUNGFRAU && detType != MOENCH) + functionNotImplemented(); + auto retval = static_cast(impl()->getUDPDataStream(port)); + return socket.sendResult(retval); +} + int ClientInterface::get_arping(Interface &socket) { auto retval = static_cast(impl()->getArping()); LOG(logDEBUG1) << "arping thread status:" << retval; @@ -1884,4 +1933,35 @@ int ClientInterface::set_readout_speed(Interface &socket) { return socket.Send(OK); } +int ClientInterface::set_udp_port_disable_meta(Interface &socket) { + auto nports = socket.Receive(); + std::vector portsDisabled; + if (nports > 0) { + portsDisabled.resize(nports); + socket.Receive(portsDisabled); + LOG(logDEBUG1) << "Disabled Ports Metadata:" << ToString(portsDisabled); + } + verifyIdle(socket); + try { + + impl()->setUDPPortsDisabledMetadata(portsDisabled); + } catch (const std::exception &e) { + throw RuntimeError("Could not update UDP ports disabled metadata [" + + std::string(e.what()) + ']'); + } + return socket.Send(OK); +} + +int ClientInterface::get_udp_port_disable_meta(Interface &socket) { + auto retvals = impl()->getUDPPortsDisabledMetadata(); + LOG(logDEBUG1) << "Receiver disabled udp ports retval:" + << ToString(retvals); + socket.Send(OK); + auto size = static_cast(retvals.size()); + socket.Send(size); + if (size > 0) + socket.Send(retvals); + return OK; +} + } // namespace sls diff --git a/slsReceiverSoftware/src/ClientInterface.h b/slsReceiverSoftware/src/ClientInterface.h index 0486367e2..07ba77a7d 100644 --- a/slsReceiverSoftware/src/ClientInterface.h +++ b/slsReceiverSoftware/src/ClientInterface.h @@ -154,7 +154,9 @@ class ClientInterface : private virtual slsDetectorDefs { int get_streaming_hwm(ServerInterface &socket); int set_streaming_hwm(ServerInterface &socket); int set_all_threshold(ServerInterface &socket); - int set_detector_datastream(ServerInterface &socket); + void validate_port_position(const portPosition port); + int set_port_udp_datastream(ServerInterface &socket); + int get_port_udp_datastream(ServerInterface &socket); int get_arping(ServerInterface &socket); int set_arping(ServerInterface &socket); int get_receiver_roi(ServerInterface &socket); @@ -168,6 +170,8 @@ class ClientInterface : private virtual slsDetectorDefs { int set_dbit_reorder(ServerInterface &socket); int get_roi_metadata(ServerInterface &socket); int set_readout_speed(ServerInterface &socket); + int set_udp_port_disable_meta(ServerInterface &socket); + int get_udp_port_disable_meta(ServerInterface &socket); Implementation *impl() { if (receiver != nullptr) { diff --git a/slsReceiverSoftware/src/DataProcessor.cpp b/slsReceiverSoftware/src/DataProcessor.cpp index e6303c188..f6359274c 100644 --- a/slsReceiverSoftware/src/DataProcessor.cpp +++ b/slsReceiverSoftware/src/DataProcessor.cpp @@ -153,14 +153,14 @@ void DataProcessor::CreateFirstFiles(const std::filesystem::path &filePath, const uint64_t fileIndex, const bool overWriteEnable, const bool silentMode, - const bool detectorDataStream) { + const bool udpDataStream) { if (dataFile == nullptr) { throw RuntimeError("file object not contstructed"); } CloseFiles(); // deactivated (half module/ single port or no roi), dont write file - if (!activated || !detectorDataStream || isOutsideRoi) { + if (!activated || !udpDataStream || isOutsideRoi) { return; } diff --git a/slsReceiverSoftware/src/DataProcessor.h b/slsReceiverSoftware/src/DataProcessor.h index 9aef85445..0f9dadaef 100644 --- a/slsReceiverSoftware/src/DataProcessor.h +++ b/slsReceiverSoftware/src/DataProcessor.h @@ -63,7 +63,7 @@ class DataProcessor : private virtual slsDetectorDefs, public ThreadObject { void CreateFirstFiles(const std::filesystem::path &filePath, const std::string &fileNamePrefix, const uint64_t fileIndex, const bool overWriteEnable, - const bool silentMode, const bool detectorDataStream); + const bool silentMode, const bool udpDataStream); #ifdef HDF5C uint32_t GetFilesInAcquisition() const; std::string CreateVirtualFile(const std::filesystem::path &filePath, diff --git a/slsReceiverSoftware/src/GeneralData.h b/slsReceiverSoftware/src/GeneralData.h index b5b6e0b26..4b61fdf56 100644 --- a/slsReceiverSoftware/src/GeneralData.h +++ b/slsReceiverSoftware/src/GeneralData.h @@ -193,6 +193,8 @@ class GeneralData { slsDetectorDefs::NO_DISCARD}; /* actual image size after ctboffset and ctbreorder */ uint32_t actualImageSize{0}; + /* bottom & top or left & right for 2 interfaces */ + std::array udpPortTypes{defs::LEFT, defs::RIGHT}; GeneralData(){}; virtual ~GeneralData(){}; @@ -344,6 +346,7 @@ class JungfrauData : public GeneralData { fifoDepth = 2500; standardheader = true; maxRowsPerReadout = 512; + udpPortTypes = {defs::BOTTOM, defs::TOP}; UpdateImageSize(); }; @@ -376,6 +379,7 @@ class MoenchData : public GeneralData { standardheader = true; maxRowsPerReadout = 400; frameDiscardMode = slsDetectorDefs::DISCARD_PARTIAL_FRAMES; + udpPortTypes = {defs::BOTTOM, defs::TOP}; UpdateImageSize(); }; @@ -468,6 +472,66 @@ class Mythen3Data : public GeneralData { }; }; +class MatterhornData : public GeneralData { + + public: + MatterhornData() { + detType = slsDetectorDefs::MATTERHORN; + headerSizeinPacket = sizeof(slsDetectorDefs::sls_detector_header); + framesPerFile = MATTERHORN_MAX_FRAMES_PER_FILE; // TODO: dummy value + fifoDepth = 50000; // TODO: dummy value + standardheader = true; + dataSize = 8192; + packetSize = headerSizeinPacket + dataSize; + // udpSocketBufferSize = 0; // TODO: dummy value + dynamicRange = 16; // default + SetCounterMask(0xf); // default all 4 counters enabled + UpdateImageSize(); + }; + + void SetDynamicRange(int dr) { + dynamicRange = dr; + UpdateImageSize(); + }; + + void SetCounterMask(const int mask) { + int n = __builtin_popcount(mask); + if (n < 1 || n > 4) { + throw RuntimeError("Invalid number of counters " + + std::to_string(n) + ". Expected 1-4."); + } + counterMask = mask; + ncounters = n; + UpdateImageSize(); + }; + + void CalculatefifoDepth() { fifoDepth = max_memory_allocated / imageSize; } + + private: + void UpdateImageSize() { + nPixelsX = nChannelsX; + nPixelsY = nChannelsY * ncounters; + + imageSize = nPixelsX * nPixelsY * GetPixelDepth(); + LOG(logINFO) << "imageSize: " << imageSize; + actualImageSize = imageSize; + + CalculatefifoDepth(); + + packetsPerFrame = imageSize / dataSize; + + LOG(logINFO) << "Packets Per Frame: " << packetsPerFrame; + }; + + private: + int ncounters{0}; + static constexpr int nChannelsX{1024}; + static constexpr int nChannelsY{512}; + + constexpr static int max_memory_allocated = + 100000; // TODO: dummy value for now +}; + class Gotthard2Data : public GeneralData { public: Gotthard2Data() { diff --git a/slsReceiverSoftware/src/Implementation.cpp b/slsReceiverSoftware/src/Implementation.cpp index 41cd95a56..e0a61199b 100644 --- a/slsReceiverSoftware/src/Implementation.cpp +++ b/slsReceiverSoftware/src/Implementation.cpp @@ -118,6 +118,7 @@ void Implementation::setDetectorType(const detectorType d) { case XILINX_CHIPTESTBOARD: case MYTHEN3: case GOTTHARD2: + case MATTERHORN: LOG(logINFO) << " ***** " << ToString(d) << " Receiver *****"; break; default: @@ -151,6 +152,9 @@ void Implementation::setDetectorType(const detectorType d) { case GOTTHARD2: generalData = new Gotthard2Data(); break; + case MATTERHORN: + generalData = new MatterhornData(); + break; default: break; } @@ -188,7 +192,7 @@ void Implementation::SetupListener(int i) { listener[i]->SetEthernetInterface(eth[i]); listener[i]->SetActivate(activated); listener[i]->SetIsOutsideRoi(portRois[i].noRoi()); - listener[i]->SetDetectorDatastream(detectorDataStream[i]); + listener[i]->SetUDPDatastream(udpDataStream[i]); listener[i]->SetSilentMode(silentMode); } @@ -265,7 +269,11 @@ void Implementation::setModulePositionId(const int id) { xy portGeometry = GetPortGeometry(); streamingPort = DEFAULT_ZMQ_RX_PORTNO + modulePos * portGeometry.x; - assert(numModules.y != 0); + if (numModules.y == 0) { + throw RuntimeError("Number of modules in y direction is 0. Cannot set " + "module position."); + } + for (unsigned int i = 0; i < listener.size(); ++i) { uint16_t row = 0, col = 0; row = (modulePos % numModules.y) * portGeometry.y; @@ -606,7 +614,7 @@ double Implementation::getProgress() const { double progress = 0; int index = 0; for (const auto &it : listener) { - if (detectorDataStream[index] && it->GetStartedFlag()) { + if (udpDataStream[index] && it->GetStartedFlag()) { progress += (it->GetListenedIndex() + 1) / totalFrames; } ++index; @@ -746,9 +754,9 @@ void Implementation::stopReceiver() { std::string summary; if (!activated) { summary = "\n\tDeactivated Receiver"; - } else if (!detectorDataStream[i]) { - summary = (i == 0 ? "\n\tDeactivated Left Port" - : "\n\tDeactivated Right Port"); + } else if (!udpDataStream[i]) { + summary = "\n\tDeactivated " + + ToString(generalData->udpPortTypes[i]) + " Port"; } else if (portRois[i].noRoi()) { summary = "\n\tNo Roi on Port[" + std::to_string(i) + ']'; } else { @@ -900,9 +908,9 @@ void Implementation::SetupWriter() { std::string fileNamePrefix = fileName + "_d" + std::to_string(modulePos * generalData->numUDPInterfaces + i); - dataProcessor[i]->CreateFirstFiles( - filePath, fileNamePrefix, fileIndex, overwriteEnable, - silentMode, detectorDataStream[i]); + dataProcessor[i]->CreateFirstFiles(filePath, fileNamePrefix, + fileIndex, overwriteEnable, + silentMode, udpDataStream[i]); } } catch (const RuntimeError &e) { shutDownUDPSockets(); @@ -999,6 +1007,10 @@ void Implementation::StartMasterWriter() { masterAttributes.gates = numberOfGates; masterAttributes.additionalJsonHeader = additionalJsonHeader; masterAttributes.readoutSpeed = readoutSpeed; + masterAttributes.udpPortTypes = { + ToString(generalData->udpPortTypes[0]), + ToString(generalData->udpPortTypes[1])}; + masterAttributes.udpPortsDisabled = udpPortsDisabledMetadata; // create master file masterFileName = dataProcessor[0]->CreateMasterFile( @@ -1100,6 +1112,11 @@ void Implementation::setNumberofUDPInterfaces(const int n) { // number of portrois should be equal to number of interfaces ResetRois(); + // reset udp data stream + udpDataStream[0] = true; + udpDataStream[1] = true; + udpPortsDisabledMetadata.clear(); + // create threads for (int i = 0; i < generalData->numUDPInterfaces; ++i) { // listener and dataprocessor threads @@ -1597,7 +1614,8 @@ uint32_t Implementation::getDynamicRange() const { void Implementation::setDynamicRange(const uint32_t i) { if (generalData->dynamicRange != i) { - if (generalData->detType == EIGER || generalData->detType == MYTHEN3) { + if (generalData->detType == EIGER || generalData->detType == MYTHEN3 || + generalData->detType == MATTERHORN) { generalData->SetDynamicRange(i); SetupFifoStructure(); } @@ -1617,15 +1635,15 @@ void Implementation::setTenGigaEnable(const bool b) { // datastream can be disabled/enabled only for Eiger 10GbE if (generalData->detType == EIGER) { if (!b) { - detectorDataStream[LEFT] = 1; - detectorDataStream[RIGHT] = 1; + udpDataStream[LEFT] = true; + udpDataStream[RIGHT] = true; } else { - detectorDataStream[LEFT] = detectorDataStream10GbE[LEFT]; - detectorDataStream[RIGHT] = detectorDataStream10GbE[RIGHT]; + udpDataStream[LEFT] = udpDataStream10GbE[LEFT]; + udpDataStream[RIGHT] = udpDataStream10GbE[RIGHT]; } LOG(logDEBUG) << "Detector datastream updated [Left: " - << ToString(detectorDataStream[LEFT]) - << ", Right: " << ToString(detectorDataStream[RIGHT]) + << ToString(udpDataStream[LEFT]) + << ", Right: " << ToString(udpDataStream[RIGHT]) << "]"; } } @@ -1675,24 +1693,49 @@ void Implementation::setActivate(bool enable) { LOG(logINFO) << "Activation: " << (activated ? "enabled" : "disabled"); } -bool Implementation::getDetectorDataStream(const portPosition port) const { - int index = (port == LEFT ? 0 : 1); - return detectorDataStream[index]; +bool Implementation::getUDPDataStream(const portPosition port) const { + int index = 0; + // top goes to udp port 2 (jungfrau & moench) + if (port == TOP || port == RIGHT) + index = 1; + return udpDataStream[index]; } -void Implementation::setDetectorDataStream(const portPosition port, - const bool enable) { - int index = (port == LEFT ? 0 : 1); - detectorDataStream10GbE[index] = enable; - LOG(logINFO) << "Detector 10GbE datastream (" << ToString(port) - << " Port): " << ToString(detectorDataStream10GbE[index]); - // update datastream for 10g - if (generalData->tengigaEnable) { - detectorDataStream[index] = detectorDataStream10GbE[index]; - LOG(logDEBUG) << "Detector datastream updated [" - << (index == 0 ? "Left" : "Right") - << "] : " << ToString(detectorDataStream[index]); +void Implementation::setUDPDataStream(const portPosition port, + const bool enable) { + int index = 0; + // top goes to udp port 2 (jungfrau & moench) + if (port == TOP || port == RIGHT) + index = 1; + // jungfrau and moench: straightforward + if (generalData->detType != EIGER) { + udpDataStream[index] = enable; + LOG(logINFO) << "Detector datastream (" << ToString(port) + << " Port): " << ToString(udpDataStream[index]); } + // eiger: data stream can be disabled/enabled only for 10GbE + else { + udpDataStream10GbE[index] = enable; + LOG(logINFO) << "Detector 10GbE datastream (" << ToString(port) + << " Port): " << ToString(udpDataStream10GbE[index]); + // update datastream for 10g + if (generalData->tengigaEnable) { + udpDataStream[index] = udpDataStream10GbE[index]; + LOG(logDEBUG) << "Detector datastream updated (" << ToString(port) + << " Port): " << ToString(udpDataStream[index]); + } + } + for (size_t i = 0; i != listener.size(); ++i) + listener[i]->SetUDPDatastream(udpDataStream[i]); +} + +void Implementation::setUDPPortsDisabledMetadata( + const std::vector &portsDisabled) { + udpPortsDisabledMetadata = portsDisabled; +} + +std::vector Implementation::getUDPPortsDisabledMetadata() const { + return udpPortsDisabledMetadata; } int Implementation::getReadNRows() const { return readNRows; } diff --git a/slsReceiverSoftware/src/Implementation.h b/slsReceiverSoftware/src/Implementation.h index 87b631e79..88c9de797 100644 --- a/slsReceiverSoftware/src/Implementation.h +++ b/slsReceiverSoftware/src/Implementation.h @@ -225,12 +225,13 @@ class Implementation : private virtual slsDetectorDefs { /** [Eiger] If deactivated, receiver will create dummy data if deactivated * padding is enabled (as it will receive nothing from detector) */ void setActivate(const bool enable); - bool getDetectorDataStream(const portPosition port) const; - /** [Eiger] If datastream is disabled, receiver will create dummy data if - * deactivated - * padding for that port is enabled (as it will receive nothing from - * detector) */ - void setDetectorDataStream(const portPosition port, const bool enable); + bool getUDPDataStream(const portPosition port) const; + /** [Jungfrau][Moench] deactivated at receiver level only + * [Eiger] deactivated at module level + */ + void setUDPDataStream(const portPosition port, const bool enable); + void setUDPPortsDisabledMetadata(const std::vector &portsDisabled); + std::vector getUDPPortsDisabledMetadata() const; int getReadNRows() const; /* [Eiger][Jungfrau][Moench] */ void setReadNRows(const int value); @@ -366,8 +367,10 @@ class Implementation : private virtual slsDetectorDefs { bool flipRows{false}; bool quadEnable{false}; bool activated{true}; - std::array detectorDataStream = {{true, true}}; - std::array detectorDataStream10GbE = {{true, true}}; + std::array udpDataStream = {{true, true}}; + std::vector udpPortsDisabledMetadata; + // only for Eiger to remember (10Gbe selectable) + std::array udpDataStream10GbE = {{true, true}}; int readNRows{0}; int thresholdEnergyeV{-1}; std::array thresholdAllEnergyeV = {{-1, -1, -1}}; diff --git a/slsReceiverSoftware/src/Listener.cpp b/slsReceiverSoftware/src/Listener.cpp index f1450e847..08443b5cb 100644 --- a/slsReceiverSoftware/src/Listener.cpp +++ b/slsReceiverSoftware/src/Listener.cpp @@ -85,17 +85,17 @@ void Listener::SetEthernetInterface(const std::string e) { void Listener::SetActivate(bool enable) { activated = enable; - disabledPort = (!activated || !detectorDataStream || isOutsideRoi); + disabledPort = (!activated || !udpDataStream || isOutsideRoi); } -void Listener::SetDetectorDatastream(bool enable) { - detectorDataStream = enable; - disabledPort = (!activated || !detectorDataStream || isOutsideRoi); +void Listener::SetUDPDatastream(bool enable) { + udpDataStream = enable; + disabledPort = (!activated || !udpDataStream || isOutsideRoi); } void Listener::SetIsOutsideRoi(bool enable) { isOutsideRoi = enable; - disabledPort = (!activated || !detectorDataStream || isOutsideRoi); + disabledPort = (!activated || !udpDataStream || isOutsideRoi); } void Listener::SetSilentMode(bool enable) { silentMode = enable; } diff --git a/slsReceiverSoftware/src/Listener.h b/slsReceiverSoftware/src/Listener.h index 628c8e349..57caacb57 100644 --- a/slsReceiverSoftware/src/Listener.h +++ b/slsReceiverSoftware/src/Listener.h @@ -42,7 +42,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject { void SetUdpPortNumber(const uint16_t portNumber); void SetEthernetInterface(const std::string e); void SetActivate(bool enable); - void SetDetectorDatastream(bool enable); + void SetUDPDatastream(bool enable); void SetIsOutsideRoi(bool enable); void SetSilentMode(bool enable); @@ -115,7 +115,7 @@ class Listener : private virtual slsDetectorDefs, public ThreadObject { uint16_t udpPortNumber{0}; std::string eth; bool activated{false}; - bool detectorDataStream{true}; + bool udpDataStream{true}; bool isOutsideRoi{false}; bool silentMode; bool disabledPort{false}; diff --git a/slsReceiverSoftware/src/MasterAttributes.cpp b/slsReceiverSoftware/src/MasterAttributes.cpp index 76907ea04..8ef96cd46 100644 --- a/slsReceiverSoftware/src/MasterAttributes.cpp +++ b/slsReceiverSoftware/src/MasterAttributes.cpp @@ -53,6 +53,10 @@ void MasterAttributes::GetJungfrauBinaryAttributes(writer *w) { WriteBinaryExposureTme(w); WriteBinaryAcquisitionPeriod(w); WriteBinaryNumberOfUDPInterfaces(w); + if (numUDPInterfaces == 2) { + WriteBinaryUDPPortsType(w); + WriteBinaryUDPPortsDisabled(w); + } WriteBinaryNumberOfRows(w); WriteBinaryReadoutSpeed(w); } @@ -63,6 +67,10 @@ void MasterAttributes::WriteJungfrauHDF5Attributes(H5::Group *group) { WriteHDF5ExposureTime(group); WriteHDF5AcquisitionPeriod(group); WriteHDF5NumberOfUDPInterfaces(group); + if (numUDPInterfaces == 2) { + WriteHDF5UDPPortsType(group); + WriteHDF5UDPPortsDisabled(group); + } WriteHDF5NumberOfRows(group); WriteHDF5ReadoutSpeed(group); } @@ -73,6 +81,10 @@ void MasterAttributes::GetMoenchBinaryAttributes(writer *w) { WriteBinaryExposureTme(w); WriteBinaryAcquisitionPeriod(w); WriteBinaryNumberOfUDPInterfaces(w); + if (numUDPInterfaces == 2) { + WriteBinaryUDPPortsType(w); + WriteBinaryUDPPortsDisabled(w); + } WriteBinaryNumberOfRows(w); WriteBinaryReadoutSpeed(w); } @@ -83,6 +95,10 @@ void MasterAttributes::WriteMoenchHDF5Attributes(H5::Group *group) { WriteHDF5ExposureTime(group); WriteHDF5AcquisitionPeriod(group); WriteHDF5NumberOfUDPInterfaces(group); + if (numUDPInterfaces == 2) { + WriteHDF5UDPPortsType(group); + WriteHDF5UDPPortsDisabled(group); + } WriteHDF5NumberOfRows(group); WriteHDF5ReadoutSpeed(group); } @@ -98,6 +114,8 @@ void MasterAttributes::GetEigerBinaryAttributes(writer *w) { WriteBinarySubExposureTime(w); WriteBinarySubAcquisitionPeriod(w); WriteBinaryQuad(w); + WriteBinaryUDPPortsType(w); + WriteBinaryUDPPortsDisabled(w); WriteBinaryNumberOfRows(w); WriteBinaryRateCorrections(w); WriteBinaryReadoutSpeed(w); @@ -114,6 +132,8 @@ void MasterAttributes::WriteEigerHDF5Attributes(H5::Group *group) { WriteHDF5SubExposureTime(group); WriteHDF5SubAcquisitionPeriod(group); WriteHDF5Quad(group); + WriteHDF5UDPPortsType(group); + WriteHDF5UDPPortsDisabled(group); WriteHDF5NumberOfRows(group); WriteHDF5RateCorrections(group); WriteHDF5ReadoutSpeed(group); @@ -690,6 +710,26 @@ void MasterAttributes::WriteHDF5TransceiverSamples(H5::Group *group) { } #endif +void MasterAttributes::WriteBinaryUDPPortsType(writer *w) { + WriteBinary(w, N_UDP_PORTS_TYPE.data(), udpPortTypes); +} + +#ifdef HDF5C +void MasterAttributes::WriteHDF5UDPPortsType(H5::Group *group) { + WriteHDF5StringArray(group, N_UDP_PORTS_TYPE.data(), udpPortTypes); +} +#endif + +void MasterAttributes::WriteBinaryUDPPortsDisabled(writer *w) { + WriteBinary(w, N_UDP_PORTS_DISABLED.data(), udpPortsDisabled); +} + +#ifdef HDF5C +void MasterAttributes::WriteHDF5UDPPortsDisabled(H5::Group *group) { + WriteHDF5Int(group, N_UDP_PORTS_DISABLED.data(), udpPortsDisabled); +} +#endif + #ifdef HDF5C void MasterAttributes::WriteHDF5String(H5::Group *group, const std::string &name, @@ -704,15 +744,25 @@ void MasterAttributes::WriteHDF5String(H5::Group *group, void MasterAttributes::WriteHDF5StringArray( H5::Group *group, const std::string &name, const std::vector &value) { - std::vector c; - for (auto &s : value) { - c.push_back(s.c_str()); + try { + std::vector c; + for (auto &s : value) { + c.push_back(s.c_str()); + } + hsize_t dims[1] = {c.size()}; + H5::DataSpace dataspace(1, dims); + H5::StrType strdatatype(H5::PredType::C_S1, H5T_VARIABLE); + H5::DataSet dataset = + group->createDataSet(name, strdatatype, dataspace); + dataset.write(c.data(), strdatatype); + } catch (H5::Exception &e) { + e.printErrorStack(); + throw RuntimeError("Could not write attribute " + name + + " in HDf5 file"); + } catch (std::exception &e) { + throw RuntimeError("Other excetion: Could not write attribute " + name + + " in HDf5 file. " + std::string(e.what())); } - hsize_t dims[1] = {c.size()}; - H5::DataSpace dataspace(1, dims); - H5::StrType strdatatype(H5::PredType::C_S1, H5T_VARIABLE); - H5::DataSet dataset = group->createDataSet(name, strdatatype, dataspace); - dataset.write(c.data(), strdatatype); } #endif diff --git a/slsReceiverSoftware/src/MasterAttributes.h b/slsReceiverSoftware/src/MasterAttributes.h index d8a188671..88a4bf975 100644 --- a/slsReceiverSoftware/src/MasterAttributes.h +++ b/slsReceiverSoftware/src/MasterAttributes.h @@ -68,6 +68,8 @@ class MasterAttributes { std::map additionalJsonHeader; uint64_t framesInFile{0}; slsDetectorDefs::speedLevel readoutSpeed{slsDetectorDefs::FULL_SPEED}; + std::vector udpPortTypes; + std::vector udpPortsDisabled; inline static const std::string_view N_DETECTOR_TYPE = "Detector Type"; inline static const std::string_view N_TIMING_MODE = "Timing Mode"; @@ -125,6 +127,9 @@ class MasterAttributes { inline static const std::string_view N_SCAN_PARAMETERS = "Scan Parameters"; inline static const std::string_view N_ADDITIONAL_JSON_HEADER = "Additional JSON Header"; + inline static const std::string_view N_UDP_PORTS_DISABLED = + "UDP Ports Disabled"; + inline static const std::string_view N_UDP_PORTS_TYPE = "UDP Ports Type"; MasterAttributes() = default; ~MasterAttributes() = default; @@ -334,7 +339,14 @@ class MasterAttributes { #ifdef HDF5C void WriteHDF5TransceiverSamples(H5::Group *group); #endif - + void WriteBinaryUDPPortsType(writer *w); +#ifdef HDF5C + void WriteHDF5UDPPortsType(H5::Group *group); +#endif + void WriteBinaryUDPPortsDisabled(writer *w); +#ifdef HDF5C + void WriteHDF5UDPPortsDisabled(H5::Group *group); +#endif /** writes according to type */ template void WriteBinaryValue(writer *w, const T &value) { if constexpr (std::is_same_v) { @@ -402,10 +414,16 @@ class MasterAttributes { template typename std::enable_if::value, void>::type WriteHDF5Int(H5::Group *group, const std::string &name, const T &value) { - H5::DataSpace dataspace(H5S_SCALAR); - auto h5type = GetHDF5Type(); - H5::DataSet dataset = group->createDataSet(name, *h5type, dataspace); - dataset.write(&value, *h5type); + try { + H5::DataSpace dataspace(H5S_SCALAR); + auto h5type = GetHDF5Type(); + H5::DataSet dataset = + group->createDataSet(name, *h5type, dataspace); + dataset.write(&value, *h5type); + } catch (std::exception &e) { + throw RuntimeError("Could not write attribute " + name + + " in HDf5 file"); + } } /** For arrays */ @@ -413,11 +431,17 @@ class MasterAttributes { typename std::enable_if::value, void>::type WriteHDF5Int(H5::Group *group, const std::string &name, const T &value) { using ElemT = typename T::value_type; - auto h5type = GetHDF5Type(); - hsize_t dims[1] = {value.size()}; - H5::DataSpace dataspace(1, dims); - H5::DataSet dataset = group->createDataSet(name, *h5type, dataspace); - dataset.write(value.data(), *h5type); + try { + auto h5type = GetHDF5Type(); + hsize_t dims[1] = {value.size()}; + H5::DataSpace dataspace(1, dims); + H5::DataSet dataset = + group->createDataSet(name, *h5type, dataspace); + dataset.write(value.data(), *h5type); + } catch (std::exception &e) { + throw RuntimeError("Could not write attribute " + name + + " in HDf5 file"); + } } #endif diff --git a/slsReceiverSoftware/src/receiver_defs.h b/slsReceiverSoftware/src/receiver_defs.h index 0d38ba749..c045f8ec6 100644 --- a/slsReceiverSoftware/src/receiver_defs.h +++ b/slsReceiverSoftware/src/receiver_defs.h @@ -19,8 +19,8 @@ namespace sls { // files // versions -#define HDF5_WRITER_VERSION (7.0) // 1 decimal places -#define BINARY_WRITER_VERSION (8.0) // 1 decimal places +#define HDF5_WRITER_VERSION (7.1) // 1 decimal places +#define BINARY_WRITER_VERSION (8.1) // 1 decimal places #define MAX_FRAMES_PER_FILE 20000 #define SHORT_MAX_FRAMES_PER_FILE 100000 @@ -31,6 +31,9 @@ namespace sls { #define XILINX_CTB_MAX_FRAMES_PER_FILE 20000 #define MYTHEN3_MAX_FRAMES_PER_FILE 10000 #define GOTTHARD2_MAX_FRAMES_PER_FILE 20000 +#define MATTERHORN_MAX_FRAMES_PER_FILE \ + 20000 // dummy value for now - maybe even specialized receiver for + // matterhorn? #define STATISTIC_FRAMENUMBER_INFINITE (20000) diff --git a/slsSupportLib/include/sls/ClientSocket.h b/slsSupportLib/include/sls/ClientSocket.h index dcfc02b25..4ef8e5da4 100644 --- a/slsSupportLib/include/sls/ClientSocket.h +++ b/slsSupportLib/include/sls/ClientSocket.h @@ -21,6 +21,7 @@ class ClientSocket : public DataSocket { private: void readReply(int &ret, void *retval, size_t retval_size); + [[noreturn]] void throwError(const std::string &msg) const; struct sockaddr_in serverAddr {}; std::string socketType; }; diff --git a/slsSupportLib/include/sls/DataSocket.h b/slsSupportLib/include/sls/DataSocket.h index 31d9afa72..c8c7fc75e 100644 --- a/slsSupportLib/include/sls/DataSocket.h +++ b/slsSupportLib/include/sls/DataSocket.h @@ -77,8 +77,6 @@ class DataSocket { std::string Receive(size_t length); - int read(void *buffer, size_t size); - int write(void *buffer, size_t size); int setTimeOut(int t_seconds); int setReceiveTimeout(int us); void close(); @@ -88,6 +86,8 @@ class DataSocket { private: int sockfd_ = -1; int fnum_{0}; + + std::string_view errno_name(int e); }; }; // namespace sls diff --git a/slsDetectorSoftware/src/SharedMemory.h b/slsSupportLib/include/sls/SharedMemory.h similarity index 97% rename from slsDetectorSoftware/src/SharedMemory.h rename to slsSupportLib/include/sls/SharedMemory.h index bbdcfdd66..006cfbcc9 100644 --- a/slsDetectorSoftware/src/SharedMemory.h +++ b/slsSupportLib/include/sls/SharedMemory.h @@ -92,7 +92,7 @@ template class SharedMemory { ~SharedMemory() { if (shared_struct) - unmapSharedMemory(); + unmapSharedMemory(); // only unmapped as resued in command line } /** memory is valid if it has the IsValid flag and is true */ @@ -168,7 +168,11 @@ template class SharedMemory { if (fd < 0) { std::string msg = "Create shared memory " + name + " failed: " + strerror(errno); - throw SharedMemoryError(msg); + if (errno == EEXIST) { + throw SharedMemoryAlreadyExistsError(msg); + } else { + throw SharedMemoryError(msg); + } } if (ftruncate(fd, sizeof(T)) < 0) { diff --git a/slsSupportLib/include/sls/sls_detector_exceptions.h b/slsSupportLib/include/sls/sls_detector_exceptions.h index 421b60549..38bc43ebf 100644 --- a/slsSupportLib/include/sls/sls_detector_exceptions.h +++ b/slsSupportLib/include/sls/sls_detector_exceptions.h @@ -17,6 +17,11 @@ class SharedMemoryError : public RuntimeError { explicit SharedMemoryError(const std::string &msg); }; +class SharedMemoryAlreadyExistsError : public SharedMemoryError { + public: + explicit SharedMemoryAlreadyExistsError(const std::string &msg); +}; + class SocketError : public RuntimeError { public: explicit SocketError(const std::string &msg); diff --git a/slsSupportLib/include/sls/sls_detector_funcs.h b/slsSupportLib/include/sls/sls_detector_funcs.h index 56db44c78..0b1b66ae6 100755 --- a/slsSupportLib/include/sls/sls_detector_funcs.h +++ b/slsSupportLib/include/sls/sls_detector_funcs.h @@ -409,7 +409,7 @@ enum detFuncs { F_GET_RECEIVER_STREAMING_HWM, F_SET_RECEIVER_STREAMING_HWM, F_RECEIVER_SET_ALL_THRESHOLD, - F_RECEIVER_SET_DATASTREAM, + F_RECEIVER_SET_UDP_DATASTREAM, F_GET_RECEIVER_ARPING, F_SET_RECEIVER_ARPING, F_RECEIVER_GET_RECEIVER_ROI, @@ -423,6 +423,9 @@ enum detFuncs { F_SET_RECEIVER_DBIT_REORDER, F_RECEIVER_GET_ROI_METADATA, F_SET_RECEIVER_READOUT_SPEED, + F_RECEIVER_GET_UDP_DATASTREAM, + F_RECEIVER_SET_UDP_PORT_DISABLE_META, + F_RECEIVER_GET_UDP_PORT_DISABLE_META, NUM_REC_FUNCTIONS }; @@ -828,7 +831,7 @@ const char* getFunctionNameFromEnum(enum detFuncs func) { case F_GET_RECEIVER_STREAMING_HWM: return "F_GET_RECEIVER_STREAMING_HWM"; case F_SET_RECEIVER_STREAMING_HWM: return "F_SET_RECEIVER_STREAMING_HWM"; case F_RECEIVER_SET_ALL_THRESHOLD: return "F_RECEIVER_SET_ALL_THRESHOLD"; - case F_RECEIVER_SET_DATASTREAM: return "F_RECEIVER_SET_DATASTREAM"; + case F_RECEIVER_SET_UDP_DATASTREAM: return "F_RECEIVER_SET_UDP_DATASTREAM"; case F_GET_RECEIVER_ARPING: return "F_GET_RECEIVER_ARPING"; case F_SET_RECEIVER_ARPING: return "F_SET_RECEIVER_ARPING"; case F_RECEIVER_GET_RECEIVER_ROI: return "F_RECEIVER_GET_RECEIVER_ROI"; @@ -842,6 +845,10 @@ const char* getFunctionNameFromEnum(enum detFuncs func) { case F_SET_RECEIVER_DBIT_REORDER: return "F_SET_RECEIVER_DBIT_REORDER"; case F_RECEIVER_GET_ROI_METADATA: return "F_RECEIVER_GET_ROI_METADATA"; case F_SET_RECEIVER_READOUT_SPEED: return "F_SET_RECEIVER_READOUT_SPEED"; + case F_RECEIVER_GET_UDP_DATASTREAM: return "F_RECEIVER_GET_UDP_DATASTREAM"; + case F_RECEIVER_SET_UDP_PORT_DISABLE_META: return "F_RECEIVER_SET_UDP_PORT_DISABLE_META"; + case F_RECEIVER_GET_UDP_PORT_DISABLE_META: return "F_RECEIVER_GET_UDP_PORT_DISABLE_META"; + case NUM_REC_FUNCTIONS: return "NUM_REC_FUNCTIONS"; default: return "Unknown Function"; diff --git a/slsSupportLib/include/sls/string_utils.h b/slsSupportLib/include/sls/string_utils.h index dc1c037ac..abeed79a7 100644 --- a/slsSupportLib/include/sls/string_utils.h +++ b/slsSupportLib/include/sls/string_utils.h @@ -96,4 +96,6 @@ bool replace_first(std::string *s, const std::string &substr, std::pair ParseHostPort(const std::string &s); +std::string to_lower(const std::string &s); + } // namespace sls diff --git a/slsSupportLib/include/sls/versionAPI.h b/slsSupportLib/include/sls/versionAPI.h index 32fba195b..4da99e33a 100644 --- a/slsSupportLib/include/sls/versionAPI.h +++ b/slsSupportLib/include/sls/versionAPI.h @@ -10,4 +10,4 @@ #define APIXILINXCTB "0.0.0 0x260506" #define APIJUNGFRAU "0.0.0 0x260424" #define APIMYTHEN3 "0.0.0 0x260506" -#define APIMATTERHORN "0.0.0 0x260212" +#define APIMATTERHORN "0.0.0 0x260529" diff --git a/slsSupportLib/src/ClientSocket.cpp b/slsSupportLib/src/ClientSocket.cpp index 117e7621c..fe62d8208 100644 --- a/slsSupportLib/src/ClientSocket.cpp +++ b/slsSupportLib/src/ClientSocket.cpp @@ -5,9 +5,11 @@ #include "sls/sls_detector_defs.h" #include "sls/sls_detector_exceptions.h" #include "sls/sls_detector_funcs.h" +#include "sls/string_utils.h" #include #include #include +#include #include #include #include @@ -24,9 +26,10 @@ ClientSocket::ClientSocket(std::string stype, const std::string &host, hints.ai_flags |= AI_CANONNAME; if (getaddrinfo(host.c_str(), nullptr, &hints, &result) != 0) { - std::string msg = "ClientSocket cannot decode host:" + host + - " on port " + std::to_string(port) + "\n"; - throw SocketError(msg); + + auto msg = fmt::format("Cannot resolve {} hostname: '{}'", + to_lower(socketType), host); + throwError(msg); } // TODO! Erik, results could have multiple entries do we need to loop @@ -40,10 +43,10 @@ ClientSocket::ClientSocket(std::string stype, const std::string &host, if (::connect(getSocketId(), (struct sockaddr *)&serverAddr, sizeof(serverAddr)) != 0) { freeaddrinfo(result); - std::string msg = "ClientSocket: Cannot connect to " + socketType + - ":" + host + " on port " + std::to_string(port) + - "\n"; - throw SocketError(msg); + auto msg = fmt::format("Cannot connect to {} on {}:{}\n", + to_lower(socketType), host, port); + + throwError(msg); } freeaddrinfo(result); } @@ -54,10 +57,19 @@ ClientSocket::ClientSocket(std::string sType, struct sockaddr_in addr) if (::connect(getSocketId(), (struct sockaddr *)&addr, sizeof(addr)) != 0) { char address[INET_ADDRSTRLEN]; inet_ntop(AF_INET, &addr.sin_addr, address, INET_ADDRSTRLEN); - std::string msg = "ClientSocket: Cannot connect to " + socketType + - ":" + address + " on port " + - std::to_string(addr.sin_port) + "\n"; - throw SocketError(msg); + auto msg = fmt::format("Cannot connect to {} on {}:{}", + to_lower(socketType), address, addr.sin_port); + throwError(msg); + } +} + +void ClientSocket::throwError(const std::string &msg) const { + if (socketType == "Receiver") { + throw ReceiverError(msg); + } else if (socketType == "Detector") { + throw DetectorError(msg); + } else { + throw GuiError(msg); } } @@ -80,26 +92,16 @@ void ClientSocket::readReply(int &ret, void *retval, size_t retval_size) { std::string mess = readErrorMessage(); // Do we need to know hostname here? // In that case save it??? - if (socketType == "Receiver") { - throw ReceiverError("Receiver returned: " + std::string(mess)); - } else if (socketType == "Detector") { - throw DetectorError("Detector returned: " + std::string(mess)); - } else { - throw GuiError(mess); - } + throwError(socketType + " returned: " + mess); } // get retval Receive(retval, retval_size); } // debugging catch (SocketError &e) { - if (socketType == "Receiver") { - throw ReceiverError("Receiver returned: " + std::string(e.what())); - } else if (socketType == "Detector") { - throw DetectorError("Detector returned: " + std::string(e.what())); - } else { - throw GuiError(e.what()); - } + auto msg = fmt::format("While reading reply from {} {}", + to_lower(socketType), e.what()); + throwError(msg); } } diff --git a/slsSupportLib/src/DataSocket.cpp b/slsSupportLib/src/DataSocket.cpp index 25d016d0b..7979f9d70 100644 --- a/slsSupportLib/src/DataSocket.cpp +++ b/slsSupportLib/src/DataSocket.cpp @@ -1,12 +1,14 @@ // SPDX-License-Identifier: LGPL-3.0-or-other // Copyright (C) 2021 Contributors to the SLS Detector Package #include "sls/DataSocket.h" +#include "sls/Timer.h" #include "sls/logger.h" #include "sls/sls_detector_exceptions.h" #include "sls/sls_detector_funcs.h" #include #include #include +#include #include #include #include @@ -21,6 +23,14 @@ namespace sls { DataSocket::DataSocket(int socketId) : sockfd_(socketId) { int value = 1; setsockopt(sockfd_, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(value)); +#ifdef SO_NOSIGPIPE + // macOS/BSD: suppress SIGPIPE when sending to a peer that closed the + // connection, so a failed send returns an error instead of killing the + // process. On Linux we instead pass MSG_NOSIGNAL to send() (see Send()). + int nosigpipe = 1; + setsockopt(sockfd_, SOL_SOCKET, SO_NOSIGPIPE, &nosigpipe, + sizeof(nosigpipe)); +#endif } DataSocket::~DataSocket() { @@ -36,6 +46,7 @@ DataSocket::~DataSocket() { void DataSocket::swap(DataSocket &other) noexcept { std::swap(sockfd_, other.sockfd_); + std::swap(fnum_, other.fnum_); } DataSocket::DataSocket(DataSocket &&move) noexcept { move.swap(*this); } @@ -48,23 +59,34 @@ void DataSocket::setFnum(const int fnum) { fnum_ = fnum; } int DataSocket::Receive(void *buffer, size_t size) { // TODO!(Erik) Add sleep? how many reties? - int bytes_expected = static_cast(size); // signed size - int bytes_read = 0; + ssize_t bytes_expected = static_cast(size); + ssize_t bytes_read = 0; + ssize_t this_read = 0; // last read result, kept for diagnostics + Timer timer; while (bytes_read < bytes_expected) { - auto this_read = + this_read = ::read(getSocketId(), reinterpret_cast(buffer) + bytes_read, bytes_expected - bytes_read); + if (this_read < 0 && errno == EINTR) + continue; // interrupted by a signal, retry if (this_read <= 0) break; bytes_read += this_read; } if (bytes_read == bytes_expected) { - return bytes_read; + return static_cast(bytes_read); } else { + int err = errno; // capture before any other call can clobber it std::ostringstream ss; ss << "TCP socket read " << bytes_read << " bytes instead of " << bytes_expected << " bytes (" << getFunctionNameFromEnum(static_cast(fnum_)) << ')'; + if (this_read == 0) + ss << ": connection closed by peer (EOF)"; + else if (this_read < 0) + ss << ": read error: " << std::strerror(err) << " (" + << errno_name(err) << ")"; + ss << " after " << timer.elapsed_ms() << " ms"; throw SocketError(ss.str()); } } @@ -78,38 +100,50 @@ std::string DataSocket::Receive(size_t length) { return buff; } int DataSocket::Send(const void *buffer, size_t size) { - int bytes_sent = 0; - int data_size = static_cast(size); // signed size - while (bytes_sent < (data_size)) { - auto this_send = ::write(getSocketId(), buffer, size); + ssize_t bytes_expected = static_cast(size); + ssize_t bytes_sent = 0; + ssize_t this_send = 0; // last write result, kept for diagnostics + // Linux: avoid SIGPIPE on a broken connection by using send() with + // MSG_NOSIGNAL. macOS/BSD lack the flag and use SO_NOSIGPIPE instead + // (set in the constructor). +#ifdef MSG_NOSIGNAL + const int send_flags = MSG_NOSIGNAL; +#else + const int send_flags = 0; +#endif + Timer timer; + while (bytes_sent < bytes_expected) { + this_send = ::send(getSocketId(), + reinterpret_cast(buffer) + bytes_sent, + bytes_expected - bytes_sent, send_flags); + if (this_send < 0 && errno == EINTR) + continue; // interrupted by a signal, retry if (this_send <= 0) break; bytes_sent += this_send; } - if (bytes_sent != data_size) { + if (bytes_sent == bytes_expected) { + return static_cast(bytes_sent); + } else { + int err = errno; // capture before any other call can clobber it std::ostringstream ss; ss << "TCP socket sent " << bytes_sent << " bytes instead of " - << data_size << " bytes (" + << bytes_expected << " bytes (" << getFunctionNameFromEnum(static_cast(fnum_)) << ')'; + if (this_send < 0) + ss << ": write error: " << std::strerror(err) << " (" + << errno_name(err) << ")"; + ss << " after " << timer.elapsed_ms() << " ms"; throw SocketError(ss.str()); } - return bytes_sent; } int DataSocket::Send(const std::string &s) { return Send(&s[0], s.size()); } -int DataSocket::write(void *buffer, size_t size) { - return ::write(getSocketId(), buffer, size); -} - -int DataSocket::read(void *buffer, size_t size) { - return ::read(getSocketId(), buffer, size); -} - int DataSocket::setReceiveTimeout(int us) { timeval t{}; - t.tv_sec = 0; - t.tv_usec = us; + t.tv_sec = us / 1000000; + t.tv_usec = us % 1000000; return ::setsockopt(getSocketId(), SOL_SOCKET, SO_RCVTIMEO, &t, sizeof(struct timeval)); } @@ -140,7 +174,9 @@ int DataSocket::setTimeOut(int t_seconds) { void DataSocket::close() { if (sockfd_ > 0) { if (::close(sockfd_)) { - throw SocketError("could not close socket"); + std::stringstream ss; + ss << "could not close socket (fd: " << sockfd_ << ")"; + throw SocketError(ss.str()); } sockfd_ = -1; } else { @@ -155,4 +191,61 @@ void DataSocket::shutDownSocket() { void DataSocket::shutdown() { ::shutdown(sockfd_, SHUT_RDWR); } +std::string_view DataSocket::errno_name(int e) { + switch (e) { +#ifdef EACCES + case EACCES: + return "EACCES"; +#endif +#ifdef EAGAIN + case EAGAIN: + return "EAGAIN"; +#endif +#ifdef EBADF + case EBADF: + return "EBADF"; +#endif +#ifdef ECONNABORTED + case ECONNABORTED: + return "ECONNABORTED"; +#endif +#ifdef ECONNREFUSED + case ECONNREFUSED: + return "ECONNREFUSED"; +#endif +#ifdef ECONNRESET + case ECONNRESET: + return "ECONNRESET"; +#endif +#ifdef EINPROGRESS + case EINPROGRESS: + return "EINPROGRESS"; +#endif +#ifdef EINTR + case EINTR: + return "EINTR"; +#endif +#ifdef EINVAL + case EINVAL: + return "EINVAL"; +#endif +#ifdef EPIPE + case EPIPE: + return "EPIPE"; +#endif +#ifdef ETIMEDOUT + case ETIMEDOUT: + return "ETIMEDOUT"; +#endif +#ifdef EWOULDBLOCK +#if EWOULDBLOCK != EAGAIN + case EWOULDBLOCK: + return "EWOULDBLOCK"; +#endif +#endif + default: + return "UNKNOWN_ERRNO"; + } +} + } // namespace sls diff --git a/slsSupportLib/src/ServerInterface.cpp b/slsSupportLib/src/ServerInterface.cpp index 92e3d7a67..8e2d4a503 100644 --- a/slsSupportLib/src/ServerInterface.cpp +++ b/slsSupportLib/src/ServerInterface.cpp @@ -10,16 +10,16 @@ namespace sls { int ServerInterface::sendResult(int ret, void *retval, int retvalSize, char *mess) { - write(&ret, sizeof(ret)); + Send(&ret, sizeof(ret)); if (ret == defs::FAIL) { if (mess != nullptr) { - write(mess, MAX_STR_LENGTH); + Send(mess, MAX_STR_LENGTH); } else { LOG(logERROR) << "No error message provided for this " "failure. Will mess up TCP\n"; } } else { - write(retval, retvalSize); + Send(retval, retvalSize); } return ret; } diff --git a/slsSupportLib/src/sls_detector_exceptions.cpp b/slsSupportLib/src/sls_detector_exceptions.cpp index d5a6ca645..369c19db8 100644 --- a/slsSupportLib/src/sls_detector_exceptions.cpp +++ b/slsSupportLib/src/sls_detector_exceptions.cpp @@ -14,6 +14,11 @@ RuntimeError::RuntimeError(const char *msg) : runtime_error(msg) { } SharedMemoryError::SharedMemoryError(const std::string &msg) : RuntimeError(msg) {} + +SharedMemoryAlreadyExistsError::SharedMemoryAlreadyExistsError( + const std::string &msg) + : SharedMemoryError(msg) {} + SocketError::SocketError(const std::string &msg) : RuntimeError(msg) {} ZmqSocketError::ZmqSocketError(const std::string &msg) : RuntimeError(msg) {} NotImplementedError::NotImplementedError(const std::string &msg) diff --git a/slsSupportLib/src/string_utils.cpp b/slsSupportLib/src/string_utils.cpp index 1426049ff..36d161e4e 100644 --- a/slsSupportLib/src/string_utils.cpp +++ b/slsSupportLib/src/string_utils.cpp @@ -75,4 +75,11 @@ std::pair ParseHostPort(const std::string &s) { return std::make_pair(host, port); } +std::string to_lower(const std::string &s) { + std::string result = s; + std::transform(result.begin(), result.end(), result.begin(), + [](unsigned char c) { return std::tolower(c); }); + return result; +} + }; // namespace sls \ No newline at end of file diff --git a/slsSupportLib/tests/test-Sockets.cpp b/slsSupportLib/tests/test-Sockets.cpp index b41c44cb4..897ed4e65 100644 --- a/slsSupportLib/tests/test-Sockets.cpp +++ b/slsSupportLib/tests/test-Sockets.cpp @@ -3,37 +3,114 @@ #include "catch.hpp" #include "sls/ClientSocket.h" #include "sls/ServerSocket.h" +#include "sls/Timer.h" +#include "sls/sls_detector_defs.h" +#include "sls/sls_detector_exceptions.h" +#include "sls/sls_detector_funcs.h" +#include #include #include #include +#include +#include +#include #include +#include namespace sls { -std::vector server() { - std::cout << "starting server\n"; - auto server = ServerSocket(1950); +// One configurable test server: accept a connection, read a 100-byte request, +// reply with `bytes_to_send` bytes (first two set to 'O','K'), optionally wait +// `hold` so the client can time out, then close. Returns the received request. +std::vector echo_server(uint16_t port, size_t bytes_to_send, + std::chrono::milliseconds hold) { + std::cout << "starting server on port " << port << '\n'; + auto server = ServerSocket(port); auto s = server.accept(); std::vector buffer(100, '\0'); s.Receive(buffer.data(), buffer.size()); - std::cout << "ServerReceived: " << std::string(buffer.begin(), buffer.end()) - << '\n'; - std::vector to_send(100, '\0'); - to_send[0] = 'O'; - to_send[1] = 'K'; - s.Send(to_send.data(), to_send.size()); + if (port == 1960) { + struct linger ling = {.l_onoff = 1, .l_linger = 0}; + + auto fd = s.getSocketId(); + setsockopt(fd, SOL_SOCKET, SO_LINGER, &ling, sizeof ling); + ::close(fd); + return buffer; + } + + if (bytes_to_send > 0) { + std::vector to_send(bytes_to_send, '\0'); + to_send[0] = 'O'; + to_send[1] = 'K'; + s.Send(to_send.data(), to_send.size()); + } + std::this_thread::sleep_for(hold); s.close(); return buffer; } +// Minimal command server speaking the same protocol as sendCommandThenRead: +// accept a connection, read the function number and a single int argument, +// then reply via ServerInterface::sendResult with OK and (arg * 2). Returns +// the {fnum, arg} pair the server received so the test can verify them. +std::pair command_server(uint16_t port) { + auto server = ServerSocket(port); + auto s = server.accept(); + int fnum = -1; + int arg = 0; + s.Receive(&fnum, sizeof(fnum)); + s.Receive(&arg, sizeof(arg)); + int retval = arg * 2; + s.sendResult(slsDetectorDefs::OK, &retval, sizeof(retval)); + s.close(); + return {fnum, arg}; +} + +// Command server that replies with a truncated message: it reads the request, +// sends the OK return code, but then sends fewer retval bytes than the client +// expects before closing, so the client's Receive hits EOF mid-read. +void short_reply_server(uint16_t port, size_t retval_bytes_to_send) { + auto server = ServerSocket(port); + auto s = server.accept(); + int fnum = -1; + int arg = 0; + s.Receive(&fnum, sizeof(fnum)); + s.Receive(&arg, sizeof(arg)); + int ret = slsDetectorDefs::OK; + s.Send(&ret, sizeof(ret)); + if (retval_bytes_to_send > 0) { + std::vector partial(retval_bytes_to_send, '\0'); + s.Send(partial.data(), partial.size()); + } + s.close(); +} + +// Server that accepts a connection but never reads from it, so a client +// trying to send more than fits in the kernel buffers will stall. A small +// receive buffer keeps the amount the test must send modest. Stays open until +// the client signals it is done (or a safety timeout) so it never closes +// mid-transfer and races the client's Send. +void non_reading_server(uint16_t port, std::atomic *client_done) { + auto server = ServerSocket(port); + auto s = server.accept(); + int rcvbuf = 1024; + setsockopt(s.getSocketId(), SOL_SOCKET, SO_RCVBUF, &rcvbuf, sizeof(rcvbuf)); + // Intentionally never Receive(): let the client's send path back up. + Timer t; + while (!client_done->load() && t.elapsed_ms() < 10000) + std::this_thread::sleep_for(std::chrono::milliseconds(10)); + s.close(); +} + TEST_CASE("The server recive the same message as we send", "[support]") { std::vector received_message(100, '\0'); std::vector sent_message(100, '\0'); const char m[]{"some message"}; std::copy(std::begin(m), std::end(m), sent_message.data()); - auto s = std::async(std::launch::async, server); + auto s = std::async(std::launch::async, echo_server, 1950, 100, + std::chrono::milliseconds(0)); std::this_thread::sleep_for(std::chrono::milliseconds(100)); auto client = DetectorSocket("localhost", 1950); client.Send(sent_message.data(), sent_message.size()); @@ -48,6 +125,200 @@ TEST_CASE("The server recive the same message as we send", "[support]") { TEST_CASE("throws on no server", "[support]") { CHECK_THROWS(DetectorSocket("localhost", 1950)); + CHECK_THROWS(ReceiverSocket("localhost", 1950)); + CHECK_THROWS(GuiSocket("localhost", 1950)); +} + +TEST_CASE("Receiving a too short message throws and reports EOF", "[support]") { + std::vector received_message(100, '\0'); + std::vector sent_message(100, '\0'); + const char m[]{"some message"}; + std::copy(std::begin(m), std::end(m), sent_message.data()); + + // Server replies with only 10 of the 100 expected bytes, then closes. + auto s = std::async(std::launch::async, echo_server, 1951, 10, + std::chrono::milliseconds(0)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + auto client = DetectorSocket("localhost", 1951); + client.Send(sent_message.data(), sent_message.size()); + + client.setFnum(F_GET_SERVER_VERSION); + + // The server only sends 10 of the 100 expected bytes and then closes the + // connection, so Receive must throw a SocketError reporting the EOF. + std::string error_message; + try { + client.Receive(received_message.data(), received_message.size()); + FAIL("Receive should have thrown on a too short message"); + } catch (const SocketError &e) { + error_message = e.what(); + } + client.close(); + s.get(); + + CHECK_THAT(error_message, + Catch::Matchers::Contains("read 10 bytes instead of 100 bytes")); + CHECK_THAT(error_message, + Catch::Matchers::Contains("connection closed by peer (EOF)")); +} + +TEST_CASE("Receiving with a socket error throws and reports the error", + "[support]") { + std::vector received_message(100, '\0'); + std::vector sent_message(100, '\0'); + const char m[]{"some message"}; + std::copy(std::begin(m), std::end(m), sent_message.data()); + + // Server stays silent (sends nothing) but keeps the connection open long + // enough for the client to time out, so the read fails with an error. + auto s = std::async(std::launch::async, echo_server, 1952, 0, + std::chrono::milliseconds(500)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + auto client = DetectorSocket("localhost", 1952); + client.Send(sent_message.data(), sent_message.size()); + + // Force read() to fail with EAGAIN/EWOULDBLOCK instead of returning EOF by + // setting a short receive timeout while the server stays silent. + client.setReceiveTimeout(100000); // 100 ms + + std::string error_message; + try { + client.Receive(received_message.data(), received_message.size()); + FAIL("Receive should have thrown on a socket error"); + } catch (const SocketError &e) { + error_message = e.what(); + } + client.close(); + s.get(); + + CHECK_THAT(error_message, + Catch::Matchers::Contains("read 0 bytes instead of 100 bytes")); + CHECK_THAT(error_message, Catch::Matchers::Contains("read error:")); +} + +TEST_CASE("Socket crash?", "[support]") { + std::vector received_message(100, '\0'); + std::vector sent_message(100, '\0'); + const char m[]{"some message"}; + std::copy(std::begin(m), std::end(m), sent_message.data()); + + auto s = std::async(std::launch::async, echo_server, 1960, 100, + std::chrono::milliseconds(0)); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + auto client = DetectorSocket("localhost", 1960); + client.Send(sent_message.data(), sent_message.size()); + + REQUIRE_THROWS( + client.Receive(received_message.data(), received_message.size())); + + // Now try to send more + // client.Send(sent_message.data(), sent_message.size()); +} + +TEST_CASE("ClientSocket throws on invalid hostname", "[support]") { + CHECK_THROWS(ReceiverSocket("invalidhostname", 1950)); + CHECK_THROWS(DetectorSocket("invalidhostname", 1950)); + CHECK_THROWS(GuiSocket("invalidhostname", 1950)); +} + +TEST_CASE("Using DetectorSocket to talk to a Server Socket", "[support]") { + constexpr uint16_t port = 1961; + constexpr int fnum = F_GET_DETECTOR_TYPE; + constexpr int arg = 21; + + auto s = std::async(std::launch::async, command_server, port); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + + auto client = DetectorSocket("localhost", port); + int retval = 0; + int ret = client.sendCommandThenRead(fnum, &arg, sizeof(arg), &retval, + sizeof(retval)); + client.close(); + + auto server_received = s.get(); + + // Client got OK and the expected return value back from the server + CHECK(ret == slsDetectorDefs::OK); + CHECK(retval == arg * 2); + // Server received the function number and argument we sent + CHECK(server_received.first == fnum); + CHECK(server_received.second == arg); + // close() resets the underlying fd + CHECK(client.getSocketId() == -1); +} + +TEST_CASE("ServerSocket replies with a too short message", "[support]") { + constexpr uint16_t port = 1962; + constexpr int fnum = F_GET_DETECTOR_TYPE; + constexpr int arg = 21; + + // Server sends the OK return code, then only 1 of the 4 expected retval + // bytes before closing. + auto s = std::async(std::launch::async, short_reply_server, port, 1); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + + auto client = DetectorSocket("localhost", port); + int retval = 0; + + std::string error_message; + try { + client.sendCommandThenRead(fnum, &arg, sizeof(arg), &retval, + sizeof(retval)); + FAIL("sendCommandThenRead should have thrown on a too short message"); + } catch (const DetectorError &e) { + error_message = e.what(); + } + client.close(); + s.get(); + + // The client read only 1 of the 4 expected retval bytes and then hit EOF. + CHECK_THAT(error_message, + Catch::Matchers::Contains("read 1 bytes instead of 4 bytes")); + CHECK_THAT(error_message, + Catch::Matchers::Contains("connection closed by peer (EOF)")); +} + +TEST_CASE("Client cannot send the expected number of bytes", "[support]") { + constexpr uint16_t port = 1963; + + // Server accepts but never reads; it stays open until we tell it the + // client is done, so it cannot close mid-transfer. + std::atomic client_done{false}; + auto s = + std::async(std::launch::async, non_reading_server, port, &client_done); + std::this_thread::sleep_for(std::chrono::milliseconds(100)); + + auto client = DetectorSocket("localhost", port); + + // Shrink the send buffer and add a short send timeout so the write stalls + // and returns before all the data is sent. + int sndbuf = 4096; + setsockopt(client.getSocketId(), SOL_SOCKET, SO_SNDBUF, &sndbuf, + sizeof(sndbuf)); + struct timeval tv {}; + tv.tv_sec = 0; + tv.tv_usec = 300000; // 300 ms + setsockopt(client.getSocketId(), SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)); + + // Much more than fits in the (shrunken) send + receive buffers, so the + // send cannot complete while the server refuses to read. + std::vector big_message(8 * 1024 * 1024, '\0'); + + std::string error_message; + try { + client.Send(big_message.data(), big_message.size()); + FAIL("Send should have thrown when it could not send all bytes"); + } catch (const SocketError &e) { + error_message = e.what(); + } + client_done = true; + client.close(); + s.get(); + + // Fewer bytes were sent than expected, reported as a write error (the + // send timed out with EAGAIN/EWOULDBLOCK). + CHECK_THAT(error_message, Catch::Matchers::Contains("bytes instead of")); + CHECK_THAT(error_message, Catch::Matchers::Contains("write error:")); } } // namespace sls diff --git a/slsSupportLib/tests/test-string_utils.cpp b/slsSupportLib/tests/test-string_utils.cpp index 15dcb7dbc..58f431f54 100644 --- a/slsSupportLib/tests/test-string_utils.cpp +++ b/slsSupportLib/tests/test-string_utils.cpp @@ -123,6 +123,31 @@ TEST_CASE("port missing") { REQUIRE(res.second == 0); } +TEST_CASE("to_lower converts uppercase to lowercase") { + REQUIRE(to_lower("HELLO") == "hello"); + REQUIRE(to_lower("Hello World") == "hello world"); +} + +TEST_CASE("to_lower leaves an already lowercase string unchanged") { + REQUIRE(to_lower("already lower") == "already lower"); +} + +TEST_CASE("to_lower only affects alphabetic characters") { + REQUIRE(to_lower("ABC123!?_-XYZ") == "abc123!?_-xyz"); +} + +TEST_CASE("to_lower on an empty string returns an empty string") { + REQUIRE(to_lower("").empty()); +} + +TEST_CASE("to_lower does not modify the original string") { + std::string original = "MixedCase"; + auto result = to_lower(original); + REQUIRE(result == "mixedcase"); + // the source string must be untouched + REQUIRE(original == "MixedCase"); +} + // TEST_CASE("concat things not being strings") } // namespace sls