Cppcheck report - ethercatcpp-core: /builds/ethercatcpp/ethercatcpp-core/src/ethercat_master/coe_utilities.cpp

/*      File: coe_utilities.cpp
 *       This file is part of the program ethercatcpp-core
 *       Program description : EtherCAT driver libraries for UNIX
 *       Copyright (C) 2017-2024 -  Robin Passama (LIRMM / CNRS) Arnaud Meline
 * (LIRMM / CNRS) Benjamin Navarro (LIRMM / CNRS). All Right reserved.
 *
 *       This software is free software: you can redistribute it and/or modify
 *       it under the terms of the CeCILL-C license as published by
 *       the CEA CNRS INRIA, either version 1
 *       of the License, or (at your option) any later version.
 *       This software is distributed in the hope that it will be useful,
 *       but WITHOUT ANY WARRANTY without even the implied warranty of
 *       MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *       CeCILL-C License for more details.
 *
 *       You should have received a copy of the CeCILL-C License
 *       along with this software. If not, it can be found on the official
 * website of the CeCILL licenses family (http://www.cecill.info/index.en.html).
 */
#include <ethercatcpp/coe_utilities.h>
#include <ethercatcpp/slave_device.h>
#include <iostream>
#include <pid/hashed_string.h>
#include <stdexcept>
#include <sstream>
#include <iomanip>

#include <pid/log/ethercatcpp-core_ethercatcpp-core.h>
namespace ethercatcpp::coe {

/////////// Object Dictionary /////////////

ObjectDictionary::ObjectDictionary(
    std::initializer_list<std::pair<std::string_view, entry>> dictionary)
    : dictionary_{} {
    for (auto& [str, obj] : dictionary) {
        dictionary_[pid::hashed_string(str)] = obj;
    }
}

const ObjectDictionary::DictionaryEntry&
ObjectDictionary::get_entry_safe(std::string_view name,
                                 std::string_view caller) const {
    auto id = pid::hashed_string(name);
    auto it = dictionary_.find(id);
    if (it == dictionary_.end()) {
        throw std::logic_error(std::string(caller) + ": no object called " +
                               std::string(name) + " in the dictionary.");
    }
    return it->second;
}

std::tuple<uint16_t, uint8_t, uint8_t>
ObjectDictionary::object(std::string_view name) const {
<--- Function parameter 'name' should be passed by const reference. [+]
Parameter 'name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    auto& obj = get_entry_safe(name, "object");
    return {obj.addr, obj.subindex, obj.bits};
}

uint32_t ObjectDictionary::mapped_pdo_object(std::string_view name) const {
<--- Function parameter 'name' should be passed by const reference. [+]
Parameter 'name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    auto& obj = get_entry_safe(name, "mapped_pdo_object");
    uint32_t ret{0};
    ret = obj.addr;
    ret <<= 8;
    ret |= obj.subindex;
    ret <<= 8;
    ret |= obj.bits;
    return ret;
}

uint16_t ObjectDictionary::addr(std::string_view name) const {
<--- Function parameter 'name' should be passed by const reference. [+]
Parameter 'name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    auto& obj = get_entry_safe(name, "addr");
    return obj.addr;
}

void ObjectDictionary::add_entry(std::string_view name,
                                 const DictionaryEntry& object) {
    auto id = pid::hashed_string(name);
    auto it = dictionary_.find(id);
    if (it != dictionary_.end()) {
        throw std::logic_error("add_entry: object " + std::string(name) +
                               " in already in the dictionary.");
    }
    dictionary_[id] = object;
}

void ObjectDictionary::add_entries(
    std::initializer_list<std::pair<std::string_view, entry>> entries) {
    for (auto& an_entry : entries) {
        add_entry(an_entry.first, an_entry.second);
    }
}

std::tuple<uint16_t, uint8_t, uint8_t>
ObjectDictionary::pdo_object_specs(uint32_t full_spec) {
    std::tuple<uint16_t, uint8_t, uint8_t> ret;
    std::get<0>(ret) = static_cast<uint16_t>(full_spec >> 16);
    std::get<1>(ret) = static_cast<uint8_t>((full_spec >> 8) & 0x0000FF);
    std::get<2>(ret) = static_cast<uint8_t>(full_spec & 0x000000FF);
    return ret;
}

size_t ObjectDictionary::size(std::string_view name) const {
<--- Function parameter 'name' should be passed by const reference. [+]
Parameter 'name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    auto& obj = get_entry_safe(name, "size");
    return obj.bits / 8;
}

/////////// PDO Mapping /////////////

PDOMapping::PDOMapping(ObjectDictionary& dictionary, uint8_t idx, bool is_tx)<--- Function 'PDOMapping' argument 1 names different: declaration 'dico' definition 'dictionary'.
    : reference_dictionnary_{&dictionary}, index_{idx}, is_tx_{is_tx} {
}

PDOMapping::PDOMapping(ObjectDictionary& dictionary, uint8_t idx, bool is_tx,<--- Function 'PDOMapping' argument 1 names different: declaration 'dico' definition 'dictionary'.
                       std::initializer_list<std::string_view> init)<--- Function 'PDOMapping' argument 4 names different: declaration 'objects' definition 'init'.
    : PDOMapping(dictionary, idx, is_tx) {
    for (auto& obj : init) {
        add_object(obj);
    }
}

uint16_t PDOMapping::map_addr() const {
    return is_tx_ ? coe_tx_pdo_map_1 | index_ : coe_rx_pdo_map_1 | index_;
}

PDOMapping::const_iterator PDOMapping::begin() const {
    return objects_mapping_.begin();
}
PDOMapping::const_iterator PDOMapping::end() const {
    return objects_mapping_.end();
}

void PDOMapping::add_object(std::string_view obj) {
<--- Function parameter 'obj' should be passed by const reference. [+]
Parameter 'obj' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    objects_mapping_.push_back(std::pair<uint8_t, uint32_t>(
        objects_mapping_.size() + 1,                      // index
        reference_dictionnary_->mapped_pdo_object(obj))); // value
}

void PDOMapping::reset() {
    objects_mapping_.clear();
}

bool PDOMapping::configure(SlaveDevice& eth_slave) const {
    uint8_t val = 0;
    bool ret{true};
    // Reset the mapping first (size =0)
    ret = eth_slave.write_sdo(map_addr(), 0x00, val) != 0;
    if (not ret) {
        pid_log << pid::error << "cannot reset mapping" << pid::flush;
        return false;
    }
    // then add objects one by one
    for (auto [idx, target] : objects_mapping_) {
        ret &= eth_slave.write_sdo(map_addr(), idx, target) != 0;
        if (not ret) {
            std::stringstream ss;
            ss << "cannot add object " << std::hex << target << " to mapping "
               << map_addr() << " subindex " << idx << "";
            pid_log << pid::error << ss.str() << pid::flush;
        }
    }
    // Set mapping size
    val = static_cast<uint8_t>(objects_mapping_.size());
    ret &= eth_slave.write_sdo(map_addr(), 0x00, val) != 0;
    if (not ret) {
        pid_log << pid::error << "cannot set mapping size" << pid::flush;
    }
    return ret;
}

size_t PDOMapping::memory_size() const {
    size_t ret{0};
    for (auto [idx, target] : objects_mapping_) {
        ret += std::get<2>(ObjectDictionary::pdo_object_specs(target));
    }
    return ret / 8; // size in bytes
}

bool PDOMapping::is_tx() const {
    return is_tx_;
}

bool PDOMapping::has_entry(std::string_view entry) const {
<--- Function parameter 'entry' should be passed by const reference. [+]
Parameter 'entry' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    uint32_t obj = reference_dictionnary_->mapped_pdo_object(entry);
    for (auto& mapped : objects_mapping_) {
        if (mapped.second == obj) {<--- Consider using std::any_of algorithm instead of a raw loop.
            return true;
        }
    }
    return false;
}

void PDOMapping::check_entry_throws(std::string_view obj) const {
    if (not has_entry(obj)) {
        std::string descr = "mapping ";
        descr += std::to_string(map_addr());
        descr += " has no entry named " + std::string(obj);
        throw std::logic_error(descr);
    }
}

size_t PDOMapping::memory_shift(std::string_view obj) const {
<--- Function parameter 'obj' should be passed by const reference. [+]
Parameter 'obj' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    check_entry_throws(obj);
    size_t shift{0};
    uint32_t obj_spec = reference_dictionnary_->mapped_pdo_object(obj);
    for (auto [idx, target] : objects_mapping_) {
        if (obj_spec == target) {
            return shift / 8;
        }
        shift += std::get<2>(ObjectDictionary::pdo_object_specs(target));
    }
    return shift / 8;
}

bool PDOMapping::check_entry_size(std::string_view obj, size_t bytes) const {
<--- Function parameter 'obj' should be passed by const reference. [+]
Parameter 'obj' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
    check_entry_throws(obj);
    size_t obj_bytes = std::get<2>(reference_dictionnary_->object(obj)) / 8;
    return obj_bytes == bytes;
}

const ObjectDictionary& PDOMapping::dictionary() const {
    return *reference_dictionnary_;
}

/////////// PDO Buffer /////////////

PDOBuffer::PDOBuffer(bool is_tx, uint16_t addr, uint32_t flags)<--- Member variable 'PDOBuffer::data_' is not initialized in the constructor.<--- Function 'PDOBuffer' argument 2 names different: declaration 'addr_' definition 'addr'.<--- Function 'PDOBuffer' argument 3 names different: declaration 'flags_' definition 'flags'.
    : is_tx_{is_tx}, addr_{addr}, flags_{flags} {
}

bool PDOBuffer::add_mapping(const PDOMapping& mapping, bool may_throw) {
    if (mapping.is_tx() != is_tx_) {
        if (may_throw) {
            std::string descr = "Error trying to assign a ";
            descr += (mapping.is_tx() ? "TX mapping" : "RX mapping");
            descr += " to a ";
            descr += (mapping.is_tx() ? "RX buffer" : "TX buffer");
            throw std::logic_error(descr);
        }
        return false;
    }
    if (contains_mapping(mapping)) {
        if (may_throw) {
            std::string descr = (is_tx_ ? "TX" : "RX");
            descr += " buffer already contains mapping ";
            descr += std::to_string(mapping.map_addr());
            throw std::logic_error(descr);
        }
        return false;
    }
    mappings_.push_back(&mapping);
    return true;
}

void PDOBuffer::bind(uint8_t* zone) {<--- Function 'bind' argument 1 names different: declaration 'data' definition 'zone'.
    data_ = zone;
}

bool PDOBuffer::contains_mapping(const PDOMapping& mapping) const {
    for (const auto& a_map : mappings_) {
        if (a_map->map_addr() == mapping.map_addr()) {<--- Consider using std::any_of algorithm instead of a raw loop.
            return true;
        }
    }
    return false;
}

void PDOBuffer::check_mapping_throws(const PDOMapping& mapping) const {
    if (not contains_mapping(mapping)) {
        std::string descr = (is_tx_ ? "TX" : "RX");
        descr += " buffer does not contain mapping ";
        descr += std::to_string(mapping.map_addr());
        throw std::logic_error(descr);
    }
}

size_t PDOBuffer::mapping_memory_shift(const PDOMapping& mapping) const {
    check_mapping_throws(mapping);
    size_t incr = 0;
    for (const auto& a_map : mappings_) {
        if (a_map->map_addr() == mapping.map_addr()) {
            return incr;
        }
        incr += a_map->memory_size();
    }
    return incr;
}

size_t PDOBuffer::entry_memory_shift(const PDOMapping& mapping,
                                     std::string_view entry) const {
    check_mapping_throws(mapping);
    if (not mapping.has_entry(entry)) {
        std::string descr = "object " + std::string(entry);
        descr +=
            "does not belong to mapping " + std::to_string(mapping.map_addr());
        throw std::logic_error(descr);
    }
    return compute_shift(mapping, entry);
}

void PDOBuffer::check_entry_throws(const PDOMapping& mapping,
                                   std::string_view entry_name,
                                   size_t bytes) const {
    if (not mapping.check_entry_size(entry_name, bytes)) {
        std::string descr = "size of object " + std::string(entry_name) + "(";
        descr += std::to_string(mapping.dictionary().size(entry_name)) + ") ";
        descr +=
            "does not match the variable size (" + std::to_string(bytes) + ")";
        throw std::logic_error(descr);
    }
}

size_t PDOBuffer::compute_shift(const PDOMapping& mapping,
                                std::string_view entry_name) const {
<--- Function parameter 'entry_name' should be passed by const reference. [+]
Parameter 'entry_name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.

    return mapping_memory_shift(mapping) + mapping.memory_shift(entry_name);
}

const uint8_t* PDOBuffer::map_memory_internal(const PDOMapping& mapping,
                                              std::string_view entry_name,
<--- Function parameter 'entry_name' should be passed by const reference. [+]
Parameter 'entry_name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
                                              size_t bytes) const {
    check_entry_throws(mapping, entry_name, bytes);
    return data_ + compute_shift(mapping, entry_name);
}

uint8_t* PDOBuffer::map_memory_internal(const PDOMapping& mapping,
                                        std::string_view entry_name,
<--- Function parameter 'entry_name' should be passed by const reference. [+]
Parameter 'entry_name' is passed by value. It could be passed as a const reference which is usually faster and recommended in C++.
                                        size_t bytes) {
    check_entry_throws(mapping, entry_name, bytes);
    return data_ + compute_shift(mapping, entry_name);
}

static std::string to_hex(uint16_t value) {
    std::ostringstream oss;
    oss << "0x" << std::hex << std::setw(4) << std::setfill('0') << value;
    return oss.str();
}

void PDOBuffer::check_mapping_size_throws(const PDOMapping& mapping,
                                          size_t bytes) const {
    check_mapping_throws(mapping);
    if (mapping.memory_size() != bytes) {
        std::string descr =
            "size of mapping " + to_hex(mapping.map_addr()) + "(";
        descr += std::to_string(mapping.memory_size()) + ") ";
        descr +=
            "does not match the variable size (" + std::to_string(bytes) + ")";
        throw std::logic_error(descr);
    }
}

uint8_t* PDOBuffer::map_memory_internal(const PDOMapping& mapping,
                                        size_t bytes) {
    check_mapping_size_throws(mapping, bytes);
    return data_ + mapping_memory_shift(mapping);
}

const uint8_t* PDOBuffer::map_memory_internal(const PDOMapping& mapping,
                                              size_t bytes) const {

    check_mapping_size_throws(mapping, bytes);
    return data_ + mapping_memory_shift(mapping);
}

uint16_t PDOBuffer::memory_size() const {
    size_t res{0};
    for (const auto& a_map : mappings_) {
        res += a_map->memory_size();<--- Consider using std::accumulate algorithm instead of a raw loop.
    }
    return static_cast<uint16_t>(res);
}

const PDOMapping& PDOBuffer::access_mapping(size_t idx) const {
    if (idx >= mappings_.size()) {
        throw std::logic_error("mapping with index " + std::to_string(idx) +
                               " doe not exist in buffer");
    }
    return *mappings_[idx];
}

void PDOBuffer::define_physical_buffer(SlaveDevice& eth_slave) {
    if (is_tx_) {
        eth_slave.define_physical_buffer(SlaveDevice::SYNCHROS_IN, addr_,
                                         flags_, memory_size());
    } else {
        eth_slave.define_physical_buffer(SlaveDevice::SYNCHROS_OUT, addr_,
                                         flags_, memory_size());
    }
}
void PDOBuffer::bind_physical_buffer(SlaveDevice& eth_slave) {
    if (is_tx_) {
        bind(eth_slave.input_buffer(addr_));
    } else {
        bind(eth_slave.output_buffer(addr_));
    }
}

bool PDOBuffer::configure(SlaveDevice& eth_slave) const {
    // configure mappings first
    for (const auto& a_map : mappings_) {
        if (not a_map->configure(eth_slave)) {<--- Consider using std::find_if algorithm instead of a raw loop.
            std::stringstream ss;
            ss << std::hex << a_map->map_addr();
            pid_log << pid::error << "cannot configure mapping 0x" << ss.str()
                    << pid::flush;
            return false;
        }
    }
    // then configure PDO Assignment
    return assign(eth_slave);
}

bool PDOBuffer::assign(SlaveDevice& eth_slave) const {
    bool res{true};
    if (is_tx_) {
        res &= eth_slave.start_status_pdo_mapping<uint16_t>();
        for (const auto& a_map : mappings_) {
            res &=<--- Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.
                eth_slave.add_status_pdo_mapping<uint16_t>(a_map->map_addr());
        }
        res &= eth_slave.end_status_pdo_mapping<uint16_t>();
    } else {
        res &= eth_slave.start_command_pdo_mapping<uint16_t>();
        for (const auto& a_map : mappings_) {
            res &=<--- Consider using std::any_of, std::all_of, std::none_of, or std::accumulate algorithm instead of a raw loop.
                eth_slave.add_command_pdo_mapping<uint16_t>(a_map->map_addr());
        }
        res &= eth_slave.end_command_pdo_mapping<uint16_t>();
    }
    return res;
}

} // namespace ethercatcpp::coe