Method emit

imperative/tablegen/targets/pybind11.cpp:17–113

};

void OpDefEmitter::emit() {
    auto className = op.getCppClassName();
    os << formatv(
            "py::class_<{0}, std::shared_ptr<{0}>, OpDef> {0}Inst(m, \"{0}\");\n\n",
            className);
    for (auto&& i : op.getMgbAttributes()) {
        if (auto attr = llvm::dyn_cast<MgbEnumAttr>(&i.attr)) {
            unsigned int enumID;
            if (auto alias = llvm::dyn_cast<MgbAliasAttr>(attr)) {
                auto&& aliasBase = alias->getAliasBase();
                enumID = llvm::cast<MgbEnumAttr>(aliasBase).getBaseRecord()->getID();
            } else {
                enumID = attr->getBaseRecord()->getID();
            }
            auto&& enumAlias = env().enumAlias;
            auto&& iter = enumAlias.find(enumID);
            if (iter == enumAlias.end()) {
                os << formatv(
                        "py::enum_<{0}::{1}>({0}Inst, \"{1}\")", className,
                        attr->getEnumName());
                std::vector<std::string> body;
                for (auto&& i : attr->getEnumMembers()) {
                    size_t d1 = i.find(' ');
                    size_t d2 = i.find('=');
                    size_t d = d1 <= d2 ? d1 : d2;
                    os << formatv(
                            "\n    .value(\"{2}\", {0}::{1}::{2})", className,
                            attr->getEnumName(), i.substr(0, d));
                    body.push_back(
                            formatv("if (str == \"{2}\") return {0}::{1}::{2};",
                                    className, attr->getEnumName(), i.substr(0, d)));
                }
                if (attr->getEnumCombinedFlag()) {
                    //! define operator |
                    os << formatv(
                            "\n    .def(\"__or__\", []({0}::{1} s0, {0}::{1} s1) {{ "
                            "\n         return static_cast<{0}::{1}>(uint32_t(s0) | "
                            "uint32_t(s1));"
                            "\n      })",
                            className, attr->getEnumName());
                    //! define operator &
                    os << formatv(
                            "\n    .def(\"__and__\", []({0}::{1} s0, {0}::{1} s1) {{"
                            "\n         return static_cast<{0}::{1}>(uint32_t(s0) & "
                            "uint32_t(s1));"
                            "\n    })",
                            className, attr->getEnumName());
                }
                os << formatv(
                        "\n    .def(py::init([](const std::string& in) {"
                        "\n        auto&& str = normalize_enum(in);"
                        "\n        {0}"
                        "\n        throw py::cast_error(\"invalid enum value \" + in);"
                        "\n    }));\n",
                        llvm::join(body, "\n        "));
                os << formatv(
                        "py::implicitly_convertible<std::string, {0}::{1}>();\n\n",
                        className, attr->getEnumName());