expandLookahead.h

/*
 * Copyright 2016 VMware, Inc.
 * SPDX-FileCopyrightText: 2016 VMware, Inc.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef MIDEND_EXPANDLOOKAHEAD_H_
#define MIDEND_EXPANDLOOKAHEAD_H_
 
#include "frontends/common/resolveReferences/resolveReferences.h"
#include "frontends/p4/typeChecking/typeChecker.h"
#include "frontends/p4/typeMap.h"
#include "ir/ir.h"
 
namespace P4 {

class DoExpandLookahead : public Transform, public ResolutionContext {
    MinimalNameGenerator nameGen;
    P4::TypeMap *typeMap;
    IR::IndexedVector<IR::Declaration> newDecls;
    bool expandHeader = true;
 
    struct ExpansionInfo {
        const IR::Statement *statement;
        unsigned width;
        const IR::Type *origType;
        const IR::PathExpression *tmp;  // temporary used for result
    };
 
    void expand(const IR::PathExpression *bitvector, const IR::Type *type, unsigned *offset,
                const IR::Expression *destination, IR::IndexedVector<IR::StatOrDecl> *output);
    ExpansionInfo *convertLookahead(const IR::MethodCallExpression *expression);
 
 public:
    explicit DoExpandLookahead(TypeMap *typeMap, bool expandHeader = true)
        : typeMap(typeMap), expandHeader(expandHeader) {
        CHECK_NULL(typeMap);
        setName("DoExpandLookahead");
    }
    Visitor::profile_t init_apply(const IR::Node *node) override {
        auto rv = Transform::init_apply(node);
        node->apply(nameGen);
 
        return rv;
    }
 
    const IR::Node *postorder(IR::AssignmentStatement *statement) override;
    const IR::Node *postorder(IR::MethodCallStatement *statement) override;
    const IR::Node *preorder(IR::P4Control *control) override {
        prune();
        return control;
    }
    const IR::Node *preorder(IR::P4Parser *parser) override {
        newDecls.clear();
        return parser;
    }
    const IR::Node *postorder(IR::P4Parser *parser) override {
        if (!newDecls.empty()) parser->parserLocals.append(newDecls);
        return parser;
    }
};

class ExpandLookahead : public PassManager {
 public:
    explicit ExpandLookahead(TypeMap *typeMap, TypeChecking *typeChecking = nullptr,
                             bool expandHeader = true) {
        if (!typeChecking) typeChecking = new TypeChecking(nullptr, typeMap);
        passes.push_back(typeChecking);
        passes.push_back(new DoExpandLookahead(typeMap, expandHeader));
        setName("ExpandLookahead");
    }
};
 
}  // namespace P4
 
#endif /* MIDEND_EXPANDLOOKAHEAD_H_ */