externInstance.h

/*
Copyright 2013-present Barefoot Networks, Inc.
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef FRONTENDS_P4_EXTERNINSTANCE_H_
#define FRONTENDS_P4_EXTERNINSTANCE_H_
 
#include <optional>
 
#include "frontends/p4/parameterSubstitution.h"
#include "lib/cstring.h"
 
namespace IR {
class ConstructorCallExpression;
class Expression;
class IAnnotated;
class PathExpression;
class Type_Extern;
class TypeMap;
template <typename T>
class Vector;
}  // namespace IR
 
namespace P4 {
 
class ReferenceMap;
class TypeMap;
 
struct ExternInstance final {
    const std::optional<cstring> name;          // The instance's name, if any.
    const IR::Expression *expression;           // The original expression passed to resolve().
    const IR::Type_Extern *type;                // The type of the instance.
    const IR::Vector<IR::Type> *typeArguments;  // The instance's type arguments;
    const IR::Vector<IR::Argument> *arguments;  // The instance's constructor arguments.
    ParameterSubstitution substitution;         // Mapping from parameter names to arguments
    const IR::IAnnotated *annotations;          // If non-null, the instance's annotations.
 
    static std::optional<ExternInstance> resolve(
        const IR::Expression *expr, ReferenceMap *refMap, TypeMap *typeMap,
        const std::optional<cstring> &defaultName = std::nullopt);
 
    static std::optional<ExternInstance> resolve(const IR::PathExpression *path,
                                                 ReferenceMap *refMap, TypeMap *typeMap);
 
    static std::optional<ExternInstance> resolve(
        const IR::ConstructorCallExpression *constructorCallExpr, ReferenceMap *refMap,
        TypeMap *typeMap, const std::optional<cstring> &name = std::nullopt);
};
 
}  // namespace P4
 
#endif /* FRONTENDS_P4_EXTERNINSTANCE_H_ */