TraditionalMapFileParser.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Deutsches Elektronen-Synchrotron DESY, MSK, ChimeraTK Project <chimeratk-support@desy.de>
// SPDX-License-Identifier: LGPL-3.0-or-later
#pragma once
 
#include "MetadataCatalogue.h"
#include "NumericAddressedRegisterCatalogue.h"
 
#include <cstdint>
#include <fstream>
#include <list>
#include <string>
 
namespace ChimeraTK::detail {
 
  class TraditionalMapFileParser {
   public:
    explicit TraditionalMapFileParser(std::string fileName);
 
    std::pair<NumericAddressedRegisterCatalogue, MetadataCatalogue> parse(std::ifstream& stream);
 
   private:
    struct ParsedLine {
      RegisterPath pathName;      
      uint32_t nElements{0};      
      uint64_t address{0};        
      uint32_t nBytes{0};         
      uint64_t bar{0};            
      uint32_t width{32};         
      int32_t nFractionalBits{0}; 
      bool signedFlag{true};      
      NumericAddressedRegisterInfo::Access registerAccess{NumericAddressedRegisterInfo::Access::READ_WRITE};
      NumericAddressedRegisterInfo::Type type{NumericAddressedRegisterInfo::Type::FIXED_POINT};
      std::vector<size_t> interruptID;
    };
 
    static std::pair<RegisterPath, std::string> splitStringAtLastDot(RegisterPath moduleDotName);
 
    static std::pair<NumericAddressedRegisterInfo::Type, int> getTypeAndNFractionalBits(
        const std::string& bitInterpretation, uint32_t width);
 
    // returns an empty vector if the type is not INTERRUPT
    static std::vector<size_t> getInterruptId(std::string accessType);
 
    static void checkFileConsitencyAndThrowIfError(NumericAddressedRegisterInfo::Access registerAccessMode,
        NumericAddressedRegisterInfo::Type registerType, uint32_t nElements, uint64_t address, uint32_t nBytes,
        uint64_t bar, uint32_t width, int32_t nFractionalBits, bool signedFlag);
 
    void parseMetaData(std::string line);
 
    ParsedLine parseLine(const std::string& line);
 
    void handle2D(const ParsedLine& pl);
 
    void handle2DNewStyle(const ParsedLine& pl);
 
    static bool isScalarOr1D(const RegisterPath& pathName);
 
    static bool is2D(const RegisterPath& pathName);
 
    static bool is2DNewStyle(RegisterPath pathName);
 
    static RegisterPath makeSequenceName(const RegisterPath& pathName, size_t index);
 
    static RegisterPath make2DName(const RegisterPath& pathName, const std::string& prefix);
 
    void make2DRegisterInfos(const ParsedLine& pl, std::list<ParsedLine>& channelLines, const std::string& prefix);
 
    NumericAddressedRegisterCatalogue _pmap;
    MetadataCatalogue _metadataCatalogue;
 
    std::string _fileName;
    uint32_t _lineNo = 0;
 
    std::vector<ParsedLine> _parsedLines;
    std::map<RegisterPath, const ParsedLine&> _parsedLinesMap;
  };
 
} // namespace ChimeraTK::detail