continuation.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_CONTINUATION_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_CONTINUATION_H_
 
#include <cstdint>
#include <deque>
#include <initializer_list>
#include <iosfwd>
#include <map>
#include <optional>
#include <string>
#include <utility>
#include <variant>
#include <vector>
 
#include "backends/p4tools/common/lib/namespace_context.h"
#include "backends/p4tools/common/lib/trace_event.h"
#include "ir/ir.h"
#include "ir/node.h"
#include "lib/cstring.h"
 
namespace Test {
class SmallStepTest;
}  // namespace Test
 
namespace P4Tools::P4Testgen {
 
class Continuation {
 public:
    //
    // TODO: Add more as needed. At least, we'd probably want to use this to model parser
    // exceptions.
    enum class Exception {
        Exit,
        NoMatch,
        Reject,
        Drop,
        PacketTooShort,
        Abort,
    };
 
    friend std::ostream &operator<<(std::ostream &out, const Exception value) {
        static std::map<Exception, std::string> strings;
        if (strings.empty()) {
#define INSERT_ELEMENT(p) strings[p] = #p
            INSERT_ELEMENT(Exception::Exit);
            INSERT_ELEMENT(Exception::NoMatch);
            INSERT_ELEMENT(Exception::Reject);
            INSERT_ELEMENT(Exception::Drop);
            INSERT_ELEMENT(Exception::Abort);
#undef INSERT_ELEMENT
        }
 
        return out << strings[value];
    }
 
    struct Return {
        std::optional<const IR::Node *> expr;
 
        bool operator==(const Return &other) const;
 
        Return() : expr(std::nullopt) {}
        explicit Return(const IR::Node *expr);
    };
 
    using PropertyValue = std::variant<cstring, uint64_t, int64_t, bool, const IR::Expression *>;
 
    struct PropertyUpdate {
        cstring propertyName;
        PropertyValue property;
 
        bool operator==(const PropertyUpdate &other) const;
 
        explicit PropertyUpdate(cstring propertyName, PropertyValue property);
    };
 
    struct Guard {
        const IR::Expression *cond;
 
        bool operator==(const Guard &other) const;
 
        explicit Guard(const IR::Expression *cond);
    };
 
    using Command = std::variant<
        const IR::Node *,
        const TraceEvent *,
        Return,
        Exception,
        PropertyUpdate,
        Guard>;
 
    class Body {
        friend class Continuation;
        friend class Test::SmallStepTest;
 
        std::deque<Command> cmds;
 
     public:
        bool empty() const;
 
        const Command next() const;
 
        void push(Command cmd);
 
        void pop();
 
        void clear();
 
        bool operator==(const Body &) const;
 
        Body(std::initializer_list<Command> cmds);
 
        explicit Body(const std::vector<Command> &cmds);
 
     private:
        Body() = default;
    };
 
    class Parameter {
        friend Continuation;
 
     public:
        const IR::PathExpression *param;
 
     private:
        explicit Parameter(const IR::PathExpression *param) : param(param) {}
    };
 
    //
    // Invariant: this parameter is uniquely named.
    std::optional<const IR::PathExpression *> parameterOpt;
    Body body;
 
    Body apply(std::optional<const IR::Node *> value_opt) const;
 
    static const Parameter *genParameter(const IR::Type *type, cstring name,
                                         const NamespaceContext *ctx);
 
    explicit Continuation(Body body) : Continuation(std::nullopt, std::move(body)) {}
 
    Continuation(std::optional<const Parameter *> parameterOpt, Body body)
        : parameterOpt(parameterOpt ? std::make_optional((*parameterOpt)->param) : std::nullopt),
          body(std::move(body)) {}
};
 
}  // namespace P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_CONTINUATION_H_ */