util.h

#ifndef BACKENDS_P4TOOLS_COMMON_LIB_UTIL_H_
#define BACKENDS_P4TOOLS_COMMON_LIB_UTIL_H_
 
#include <algorithm>
#include <cstdint>
#include <iterator>
#include <optional>
#include <ostream>
#include <string>
#include <utility>
#include <vector>
 
#include <boost/format.hpp>
#include <boost/random/mersenne_twister.hpp>
 
#include "ir/ir.h"
#include "lib/big_int_util.h"
#include "lib/cstring.h"
#include "lib/log.h"
 
namespace P4Tools {
 
inline std::string logHelper(boost::format &f) { return f.str(); }
 
template <class T, class... Args>
std::string logHelper(boost::format &f, T &&t, Args &&...args) {
    return logHelper(f % std::forward<T>(t), std::forward<Args>(args)...);
}
 
// https://stackoverflow.com/a/25859856
template <typename... Arguments>
void printFeature(const std::string &label, int level, const std::string &fmt,
                  Arguments &&...args) {
    boost::format f(fmt);
 
    auto result = logHelper(f, std::forward<Arguments>(args)...);
 
    LOG_FEATURE(label.c_str(), level, result);
}
 
class Utils {
    /* =========================================================================================
     *  Seeds, timestamps, randomness.
     * ========================================================================================= */
 private:
    static boost::random::mt19937 rng;
 
    static std::optional<uint32_t> currentSeed;
 
 public:
    static std::string getTimeStamp();
 
    static void setRandomSeed(int seed);
 
    static std::optional<uint32_t> getCurrentSeed();
 
    static uint64_t getRandInt(uint64_t max);
 
    static big_int getRandBigInt(big_int max);
 
    static const IR::Constant *getRandConstantForWidth(int bitWidth);
 
    static const IR::Constant *getRandConstantForType(const IR::Type_Bits *type);
 
    /* =========================================================================================
     *  Other.
     * ========================================================================================= */
 public:
    static const IR::MethodCallExpression *generateInternalMethodCall(
        cstring methodName, const std::vector<const IR::Expression *> &argVector,
        const IR::Type *returnType = IR::Type_Void::get(),
        const IR::ParameterList *paramList = new IR::ParameterList());
 
    template <typename T>
    static void shuffle(T *inp) {
        std::shuffle(inp->begin(), inp->end(), rng);
    }
 
    template <typename Iter>
    static Iter pickRandom(Iter start, Iter end) {
        int random = getRandInt(std::distance(start, end) - 1);
        std::advance(start, random);
        return start;
    }
 
    template <typename ContainerType>
    static std::string containerToString(const ContainerType &container) {
        std::stringstream stringStream;
 
        stringStream << '[';
        auto val = container.cbegin();
        if (val != container.cend()) {
            stringStream << *val++;
            while (val != container.cend()) {
                stringStream << ", " << *val++;
            }
        }
        stringStream << ']';
        return stringStream.str();
    }
};
 
std::vector<const IR::Type_Declaration *> argumentsToTypeDeclarations(
    const IR::IGeneralNamespace *ns, const IR::Vector<IR::Argument> *inputArgs);
 
const IR::IDeclaration *findProgramDecl(const IR::IGeneralNamespace *ns, const IR::Path *path);
 
const IR::IDeclaration *findProgramDecl(const IR::IGeneralNamespace *ns,
                                        const IR::PathExpression *pathExpr);
 
const IR::Type_Declaration *resolveProgramType(const IR::IGeneralNamespace *ns,
                                               const IR::Type_Name *type);
 
}  // namespace P4Tools
 
#endif /* BACKENDS_P4TOOLS_COMMON_LIB_UTIL_H_ */