From 0a4cfb77db7f6a2bb818d5651d13a4b78f7cc36f Mon Sep 17 00:00:00 2001 From: Miodrag Milanovic Date: Fri, 3 May 2024 10:30:31 +0200 Subject: [PATCH] Implementation as in D2 deliverable --- himbaechel/uarch/ng-ultra/CMakeLists.txt | 31 + himbaechel/uarch/ng-ultra/bitstream.cc | 389 + himbaechel/uarch/ng-ultra/cells.cc | 91 + himbaechel/uarch/ng-ultra/constids.inc | 6023 +++- himbaechel/uarch/ng-ultra/csv.cc | 212 + himbaechel/uarch/ng-ultra/extra_data.h | 65 + himbaechel/uarch/ng-ultra/gen/arch_gen.py | 675 + himbaechel/uarch/ng-ultra/json.hpp | 24766 ++++++++++++++++ himbaechel/uarch/ng-ultra/ng_ultra.cc | 500 +- himbaechel/uarch/ng-ultra/ng_ultra.h | 84 + .../uarch/ng-ultra/ng_ultra_arch_gen.py | 33 - himbaechel/uarch/ng-ultra/pack.cc | 691 + himbaechel/uarch/ng-ultra/pack.h | 81 + 13 files changed, 33507 insertions(+), 134 deletions(-) create mode 100644 himbaechel/uarch/ng-ultra/bitstream.cc create mode 100644 himbaechel/uarch/ng-ultra/cells.cc create mode 100644 himbaechel/uarch/ng-ultra/csv.cc create mode 100644 himbaechel/uarch/ng-ultra/extra_data.h create mode 100644 himbaechel/uarch/ng-ultra/gen/arch_gen.py create mode 100644 himbaechel/uarch/ng-ultra/json.hpp create mode 100644 himbaechel/uarch/ng-ultra/ng_ultra.h delete mode 100644 himbaechel/uarch/ng-ultra/ng_ultra_arch_gen.py create mode 100644 himbaechel/uarch/ng-ultra/pack.cc create mode 100644 himbaechel/uarch/ng-ultra/pack.h diff --git a/himbaechel/uarch/ng-ultra/CMakeLists.txt b/himbaechel/uarch/ng-ultra/CMakeLists.txt index e7437bde..99ec4e9e 100644 --- a/himbaechel/uarch/ng-ultra/CMakeLists.txt +++ b/himbaechel/uarch/ng-ultra/CMakeLists.txt @@ -1,2 +1,33 @@ message(STATUS "Configuring Himbaechel-NG-ULTRA uarch") +cmake_minimum_required(VERSION 3.5) +project(himbaechel-ng-ultra-chipdb NONE) +set(HIMBAECHEL_PRJBEYOND_DB "" CACHE STRING + "Path to a Project Beyond database") + +set(chipdb_binaries) +file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/share/himbaechel/ng-ultra) +foreach(device "NG-ULTRA") + if("${HIMBAECHEL_PRJBEYOND_DB}" STREQUAL "") + message(SEND_ERROR "HIMBAECHEL_PRJBEYOND_DB must be set to a prjbeyond database checkout") + endif() + + set(device_bba ${CMAKE_BINARY_DIR}/share/himbaechel/ng-ultra/ng-ultra.bba) + set(device_bin ${CMAKE_BINARY_DIR}/share/himbaechel/ng-ultra/ng-ultra.bin) + add_custom_command( + OUTPUT ${device_bin} + COMMAND ${Python3_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/gen/arch_gen.py --db ${HIMBAECHEL_PRJBEYOND_DB} --device ${device} --bba ${device_bba} + COMMAND bbasm ${BBASM_ENDIAN_FLAG} ${device_bba} ${device_bin}.new + # atomically update + COMMAND ${CMAKE_COMMAND} -E rename ${device_bin}.new ${device_bin} + DEPENDS + bbasm + ${CMAKE_CURRENT_SOURCE_DIR}/gen/arch_gen.py + ${CMAKE_CURRENT_SOURCE_DIR}/constids.inc + VERBATIM) + list(APPEND chipdb_binaries ${device_bin}) +endforeach() + +add_custom_target(chipdb-himbaechel-ng-ultra ALL DEPENDS ${chipdb_binaries}) +install(DIRECTORY ${CMAKE_BINARY_DIR}/share/himbaechel/ng-ultra/ DESTINATION share/nextpnr/himbaechel/ng-ultra + PATTERN "*.bba" EXCLUDE) diff --git a/himbaechel/uarch/ng-ultra/bitstream.cc b/himbaechel/uarch/ng-ultra/bitstream.cc new file mode 100644 index 00000000..755ac64a --- /dev/null +++ b/himbaechel/uarch/ng-ultra/bitstream.cc @@ -0,0 +1,389 @@ +/* + * nextpnr -- Next Generation Place and Route + * + * Copyright (C) 2024 Miodrag Milanovic + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include +#include + +#include +#include + +#include "json.hpp" + +#include "extra_data.h" +#include "himbaechel_api.h" +#include "log.h" +#include "nextpnr.h" +#include "util.h" + +#include "ng_ultra.h" + +#define HIMBAECHEL_CONSTIDS "uarch/ng-ultra/constids.inc" +#include "himbaechel_constids.h" + +NEXTPNR_NAMESPACE_BEGIN + +namespace { +struct BitstreamJsonBackend +{ + Context *ctx; + nlohmann::json json; + NgUltraImpl *uarch; + std::ostream &out; + + BitstreamJsonBackend(Context *ctx, NgUltraImpl *uarch, std::ostream &out) : ctx(ctx), uarch(uarch), out(out){}; + + std::string update_name(std::string tile, std::string name) + { + if (boost::starts_with(tile,"FENCE[")) { + char last = tile[tile.size()-2]; + switch(last) + { + case 'T': + case 'B': + case 'U': + case 'L': + std::string loc = tile.substr(tile.find("[")+1, tile.find("x")-tile.find("[")); + boost::replace_all(name, "1x", loc); + return name; + } + } + if (boost::starts_with(tile,"TILE[") && boost::algorithm::contains(name,".FE")) { + std::string last = name.substr(name.rfind('.') + 1); + if (last[0]=='D') { + boost::replace_all(name, ".D", "."); + boost::replace_all(name, ".FE", ".DFF"); + return name; + } + if (last=="L" || last=="R") { + boost::replace_all(name, ".FE", ".DFF"); + return name; + } + if (last=="CK") { + boost::replace_all(name, ".FE", ".DFF"); + return name; + } + if (last[0]=='L') { + boost::replace_all(name, ".L", "."); + boost::replace_all(name, ".FE", ".LUT"); + return name; + } + if (last[0]=='P') { + boost::replace_all(name, ".PI", ".I"); + boost::replace_all(name, ".FE", ".LUT"); + return name; + } + } + return name; + } + + void add_net(std::set &nets, std::string src_tile, std::string src_name, std::string dst_tile, std::string dst_name, IdString src_type, IdString dst_type) + { + if (src_type.in(ctx->id("CROSSBAR_INPUT_WIRE"), ctx->id("LUT_PERMUTATION_WIRE"), ctx->id("MUX_WIRE"), ctx->id("INTERCONNECT_INPUT"))) return; + if (dst_type == ctx->id("MUX_WIRE")) + dst_name = dst_name.substr(0, dst_name.rfind('.')); + src_name = update_name(src_tile, src_name); + dst_name = update_name(dst_tile, dst_name); + + nets.emplace(stringf("%s:%s->%s:%s", src_tile.c_str(), src_name.c_str(), dst_tile.c_str(), dst_name.c_str())); + } + + std::string cleanup_name(std::string name) + { + std::replace(name.begin(), name.end(), '$', '_'); + return name; + } + + void write_nets() + { + for (auto &net : ctx->nets) { + NetInfo *ni = net.second.get(); + if (ni->wires.size()==0) continue; + auto& cfg = json["nets"][cleanup_name(ni->name.c_str(ctx))]; + std::set nets; + for (auto &w : ni->wires) { + if (w.second.pip != PipId()) { + PipId pip = w.second.pip; + auto &pd = chip_pip_info(ctx->chip_info, pip); + const auto &extra_data = *reinterpret_cast(pd.extra_data.get()); + WireId swire = ctx->getPipSrcWire(pip); + IdString src = ctx->getWireName(swire)[1]; + IdString src_type = ctx->getWireType(swire); + + IdString src_orig = IdString(chip_tile_info(ctx->chip_info, pip.tile).wires[pd.src_wire].name); + IdString src_orig_type = IdString(chip_tile_info(ctx->chip_info, pip.tile).wires[pd.src_wire].wire_type); + + WireId dwire = ctx->getPipDstWire(pip); + IdString dst = ctx->getWireName(dwire)[1]; + IdString dst_type = ctx->getWireType(dwire); + + std::string s_tile_name = uarch->tile_name(swire.tile); + std::string tile_name = uarch->tile_name(pip.tile); + + if (src_orig!=src) + add_net(nets, s_tile_name, src.c_str(ctx), tile_name, src_orig.c_str(ctx), src_type, src_orig_type); + if (!extra_data.name || (extra_data.type != PipExtra::PIP_EXTRA_BYPASS && extra_data.type != PipExtra::PIP_EXTRA_VIRTUAL && extra_data.type != PipExtra::PIP_EXTRA_MUX)) + add_net(nets, tile_name, src_orig.c_str(ctx), tile_name, dst.c_str(ctx), src_orig_type, dst_type); + } else if (ni->wires.size()==1) { + IdString src = ctx->getWireName(w.first)[1]; + IdString src_type = ctx->getWireType(w.first); + std::string s_tile_name = uarch->tile_name(w.first.tile); + for (auto &u : ni->users){ + std::string tile_name = uarch->tile_name(u.cell->bel.tile); + IdString bel_name = ctx->getBelName(u.cell->bel)[1]; + add_net(nets, s_tile_name, src.c_str(ctx), tile_name, stringf("%s.%s", bel_name.c_str(ctx), u.port.c_str(ctx)), src_type, src_type); + } + } + } + cfg = nets; + } + + } + + + template + std::string str_or_n_value(const dict &ct, const KeyType &key, std::string def = "N") + { + auto found = ct.find(key); + if (found == ct.end()) + return def; + else { + if (!found->second.is_string) + log_error("Expecting string value but got integer %d.\n", int(found->second.intval)); + if (found->second.as_string().empty()) + return def; + return found->second.as_string(); + } + }; + + + nlohmann::json &get_cfg(CellInfo *cell, std::string type = "", std::string rename = "") + { + auto& cfg = json["instances"][cleanup_name(rename.empty() ? cell->name.c_str(ctx) : rename.c_str())]; + std::string tile_name = uarch->tile_name(cell->bel.tile); + IdString idx = ctx->getBelName(cell->bel)[1]; + std::string belname = idx.c_str(ctx); + cfg["location"] = tile_name + ":" + belname; + cfg["type"] = type.empty() ? str_or_default(cell->params, ctx->id("type"), "") : type; + return cfg; + } + + nlohmann::json &get_cfg_fe(CellInfo *cell, std::string type, std::string replace, std::string postfix = "") + { + auto& cfg = json["instances"][cleanup_name(cell->name.c_str(ctx)) + postfix]; + std::string tile_name = uarch->tile_name(cell->bel.tile); + IdString idx = ctx->getBelName(cell->bel)[1]; + std::string belname = idx.c_str(ctx); + boost::replace_all(belname, ".FE", replace); + cfg["location"] = tile_name + ":" + belname; + cfg["type"] = type; + return cfg; + } + + void write_iop(CellInfo *cell) { + auto& cfg = get_cfg(cell, "", str_or_default(cell->params, ctx->id("iobname"), "")); + //cfg["config"]["alias_vhdl"] = str_or_default(cell->params, ctx->id("alias_vhdl"), ""); + //cfg["config"]["alias_vlog"] = str_or_default(cell->params, ctx->id("alias_vlog"), ""); + //cfg["config"]["differential"] = str_or_n_value(cell->params, ctx->id("differential"), "N"); + cfg["config"]["drive"] = str_or_default(cell->params, ctx->id("drive"), "2mA"); + //cfg["config"]["dynDrive"] = str_or_n_value(cell->params, ctx->id("dynDrive"), "N"); + //cfg["config"]["dynInput"] = str_or_n_value(cell->params, ctx->id("dynInput"), "N"); + //cfg["config"]["dynTerm"] = str_or_n_value(cell->params, ctx->id("dynTerm"), "N"); + //cfg["config"]["extra"] = int_or_default(cell->params, ctx->id("extra"), 2); + //cfg["config"]["inputDelayLine"] = str_or_default(cell->params, ctx->id("inputDelayLine"), ""); + //cfg["config"]["inputDelayOn"] = str_or_n_value(cell->params, ctx->id("inputDelayOn"), "N"); + //cfg["config"]["inputSignalSlope"] = str_or_default(cell->params, ctx->id("inputSignalSlope"), ""); + cfg["config"]["location"] = str_or_default(cell->params, ctx->id("location"), ""); + //cfg["config"]["locked"] = bool_or_default(cell->params, ctx->id("locked"), false); + //cfg["config"]["outputCapacity"] = str_or_default(cell->params, ctx->id("outputCapacity"), ""); + //cfg["config"]["outputDelayLine"] = str_or_default(cell->params, ctx->id("outputDelayLine"), ""); + //cfg["config"]["outputDelayOn"] = str_or_n_value(cell->params, ctx->id("outputDelayOn"), "N"); + //cfg["config"]["slewRate"] = str_or_default(cell->params, ctx->id("slewRate"), ""); + cfg["config"]["standard"] = str_or_default(cell->params, ctx->id("standard"), "LVCMOS"); + //cfg["config"]["termination"] = str_or_n_value(cell->params, ctx->id("termination"), "N"); + //cfg["config"]["terminationReference"] = str_or_n_value(cell->params, ctx->id("terminationReference"), "N"); + //cfg["config"]["turbo"] = str_or_n_value(cell->params, ctx->id("turbo"), "N"); + //cfg["config"]["weakTermination"] = str_or_n_value(cell->params, ctx->id("weakTermination"), "N"); + + std::string tile_name = uarch->tile_name(cell->bel.tile); + std::string bank = tile_name.substr(0, tile_name.rfind(':')); + if (uarch->bank_voltage.count(bank)==0) { + if (bank=="IOB0" || bank=="IOB1" || bank=="IOB6" || bank=="IOB7") + uarch->bank_voltage[bank] = "3.3V"; + else + uarch->bank_voltage[bank] = "1.8V"; + } + } + + void write_dfr(CellInfo *cell) { + auto& cfg = get_cfg(cell, "BFR"); + //cfg["config"]["data_inv"] = bool_or_default(cell->params, ctx->id("data_inv"), false); + cfg["config"]["dff_edge"] = bool_or_default(cell->params, ctx->id("dff_edge"), false); + //cfg["config"]["dff_init"] = bool_or_default(cell->params, ctx->id("dff_init"), false); + //cfg["config"]["dff_load"] = bool_or_default(cell->params, ctx->id("dff_load"), false); + cfg["config"]["dff_sync"] = bool_or_default(cell->params, ctx->id("dff_sync"), false); + //cfg["config"]["dff_type"] = bool_or_default(cell->params, ctx->id("dff_type"), false); + //cfg["config"]["location"] = str_or_default(cell->params, ctx->id("location"), ""); + cfg["config"]["mode"] = int_or_default(cell->params, ctx->id("mode"), 2); + //cfg["config"]["path"] = int_or_default(cell->params, ctx->id("path"), 0); + cfg["config"]["iobname"] = str_or_default(cell->params, ctx->id("iobname"), ""); + } + + void write_cy(CellInfo *cell) { + auto& cfg = get_cfg(cell, "CY"); + cfg["config"]["add_carry"] = int_or_default(cell->params, ctx->id("add_carry"), 0); + cfg["config"]["shifter"] = bool_or_default(cell->params, ctx->id("shifter"), false); + } + + void write_fe(CellInfo *cell) { + if (bool_or_default(cell->params, id_lut_used)) { + auto& cfg = get_cfg_fe(cell, "LUT", ".LUT"); + Property init = get_or_default(cell->params, id_lut_table, Property()).extract(0, 16); + std::string lut = init.str; + std::reverse(lut.begin(), lut.end()); + cfg["config"]["lut_table"] = lut; + } + if (bool_or_default(cell->params, id_dff_used)) { + std::string subtype = str_or_default(cell->params, ctx->id("type"), "DFF"); + auto& cfg = get_cfg_fe(cell, subtype, ".DFF", "_D"); + if (subtype =="DFF") { + //cfg["config"]["dff_ctxt"] = int_or_default(cell->params, ctx->id("dff_ctxt"), 0); + cfg["config"]["dff_edge"] = bool_or_default(cell->params, ctx->id("dff_edge"), false); + cfg["config"]["dff_init"] = bool_or_default(cell->params, ctx->id("dff_init"), false); + cfg["config"]["dff_load"] = bool_or_default(cell->params, ctx->id("dff_load"), false); + cfg["config"]["dff_sync"] = bool_or_default(cell->params, ctx->id("dff_sync"), false); + cfg["config"]["dff_type"] = bool_or_default(cell->params, ctx->id("dff_type"), false); + } + } + } + + void write_iom(CellInfo *cell) { + auto& cfg = get_cfg(cell, "IOM"); + cfg["config"]["pads_path"] = str_or_default(cell->params, ctx->id("pads_path"), ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"); + } + + void write_gck(CellInfo *cell) { + auto& cfg = get_cfg(cell, "GCK"); + cfg["config"]["inv_in"] = bool_or_default(cell->params, ctx->id("inv_in"), false); + cfg["config"]["inv_out"] = bool_or_default(cell->params, ctx->id("inv_out"), false); + cfg["config"]["std_mode"] = str_or_default(cell->params, ctx->id("std_mode"), "BYPASS"); + } + + void write_wfg(CellInfo *cell) { + std::string subtype = str_or_default(cell->params, ctx->id("type"), "WFB"); + get_cfg(cell, subtype); + } + + void write_interconnections() + { + for (auto &net : ctx->nets) { + NetInfo *ni = net.second.get(); + if (ni->wires.size()==0) continue; + std::vector nets; + for (auto &w : ni->wires) { + if (w.second.pip != PipId()) { + PipId pip = w.second.pip; + const auto &pip_data = chip_pip_info(ctx->chip_info, w.second.pip); + const auto &extra_data = *reinterpret_cast(pip_data.extra_data.get()); + if (!extra_data.name or extra_data.type != PipExtra::PIP_EXTRA_INTERCONNECT) continue; + auto &pd = chip_pip_info(ctx->chip_info, pip); + IdString src = IdString(chip_tile_info(ctx->chip_info, pip.tile).wires[pd.src_wire].name); + std::string tile_name = uarch->tile_name(pip.tile); + std::string src_name = src.c_str(ctx); + std::string type = "OTC"; + if (src_name.find("UI1x") != std::string::npos) + type = "ITC"; + if (boost::starts_with(src_name,"SO1.")) type = "OTS"; + if (boost::starts_with(src_name,"SI1.")) type = "ITS"; + std::string name = cleanup_name(std::string(ni->name.c_str(ctx))+ "_" + type); + while (json["instances"].contains(name)) + name += "_2"; + auto& cfg = json["instances"][name]; + cfg["type"] = type; + src_name = update_name(tile_name, src_name); + src_name = src_name.substr(0, src_name.size() - 2); + cfg["location"] = tile_name + ":" + src_name; + } + } + } + } + + void write_instances() + { + for (auto &cell : ctx->cells) { + switch (cell.second->type.index) { + case id_IOP.index : write_iop(cell.second.get()); break; + case id_IOTP.index : write_iop(cell.second.get()); break; + case id_BEYOND_FE.index : write_fe(cell.second.get()); break; + case id_CY.index : write_cy(cell.second.get()); break; + case id_WFG.index : write_wfg(cell.second.get()); break; + case id_GCK.index : write_gck(cell.second.get()); break; + case id_IOM.index : write_iom(cell.second.get()); break; + case id_DDFR.index: write_dfr(cell.second.get()); break; + case id_DFR.index: write_dfr(cell.second.get()); break; + //case id_XLUT.index: + //case id_RAM.index: + //case id_RF.index: + //case id_XRF.index: + //case id_FIFO.index: + //case id_XFIFO.index: + //case id_CDC.index: + //case id_XCDC.index: + //case id_CRX.index: + //case id_CTX.index: + //case id_DSP.index: + //case id_PLL.index: + //case id_PMA.index: + //case id_Service.index: + //case id_SOCIF.index: + } + } + write_interconnections(); + } + + void write_setup() + { + json["setup"]["variant"] = "NG-ULTRA"; + auto& cfg = json["setup"]["iobanks"]; + for (auto &bank : uarch->bank_voltage) + cfg[bank.first] = bank.second; + } + + void write_json() + { + write_nets(); + write_instances(); + write_setup(); + + out << std::setw(4) << json << std::endl; + } +}; + +} // namespace + +void NgUltraImpl::write_bitstream_json(const std::string &filename) +{ + std::ofstream out(filename); + if (!out) + log_error("failed to open file %s for writing (%s)\n", filename.c_str(), strerror(errno)); + + BitstreamJsonBackend be(ctx, this, out); + be.write_json(); +} + +NEXTPNR_NAMESPACE_END diff --git a/himbaechel/uarch/ng-ultra/cells.cc b/himbaechel/uarch/ng-ultra/cells.cc new file mode 100644 index 00000000..ce3fa579 --- /dev/null +++ b/himbaechel/uarch/ng-ultra/cells.cc @@ -0,0 +1,91 @@ +/* + * nextpnr -- Next Generation Place and Route + * + * Copyright (C) 2023 Miodrag Milanovic + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include "nextpnr.h" +#include "pack.h" + +#define HIMBAECHEL_CONSTIDS "uarch/ng-ultra/constids.inc" +#include "himbaechel_constids.h" + +NEXTPNR_NAMESPACE_BEGIN + +std::unique_ptr NgUltraPacker::create_cell(IdString type, IdString name) +{ + auto cell = std::make_unique(ctx, name, type); + + auto add_port = [&](const std::string &name, PortType dir) { + IdString id = ctx->id(name); + cell->ports[id].name = id; + cell->ports[id].type = dir; + }; + if (type == id_BEYOND_FE) { + add_port("I1", PORT_IN); + add_port("I2", PORT_IN); + add_port("I3", PORT_IN); + add_port("I4", PORT_IN); + add_port("LO", PORT_OUT); + add_port("DI", PORT_IN); + add_port("L", PORT_IN); + add_port("CK", PORT_IN); + add_port("R", PORT_IN); + add_port("DO", PORT_OUT); + } + return cell; +} + +CellInfo *NgUltraPacker::create_cell_ptr(IdString type, IdString name) +{ + CellInfo *cell = ctx->createCell(name, type); + + auto add_port = [&](const std::string &name, PortType dir) { + IdString id = ctx->id(name); + cell->ports[id].name = id; + cell->ports[id].type = dir; + }; + if (type == id_BEYOND_FE) { + add_port("I1", PORT_IN); + add_port("I2", PORT_IN); + add_port("I3", PORT_IN); + add_port("I4", PORT_IN); + add_port("LO", PORT_OUT); + add_port("DI", PORT_IN); + add_port("L", PORT_IN); + add_port("CK", PORT_IN); + add_port("R", PORT_IN); + add_port("DO", PORT_OUT); + } else if (type == id_DFR) { + add_port("I", PORT_IN); + add_port("O", PORT_OUT); + add_port("L", PORT_IN); + add_port("CK", PORT_IN); + add_port("R", PORT_IN); + } else if (type == id_DDFR) { + add_port("I", PORT_IN); + add_port("O", PORT_OUT); + add_port("L", PORT_IN); + add_port("CK", PORT_IN); + add_port("R", PORT_IN); + add_port("I2", PORT_IN); + add_port("O2", PORT_OUT); + add_port("CKF", PORT_IN); + } + return cell; +} + +NEXTPNR_NAMESPACE_END diff --git a/himbaechel/uarch/ng-ultra/constids.inc b/himbaechel/uarch/ng-ultra/constids.inc index b40d5be8..73cd31ff 100644 --- a/himbaechel/uarch/ng-ultra/constids.inc +++ b/himbaechel/uarch/ng-ultra/constids.inc @@ -1,14 +1,6013 @@ -X(LUT4) -X(DFF) -X(CLK) -X(D) -X(F) -X(Q) -X(INBUF) -X(OUTBUF) +// autogenerated items +// BEYOND_FE +X(BEYOND_FE) +X(CK) +X(DC) +X(DI) +X(DJ) +X(DK) +X(DO) +X(DP) +X(DS) +X(I1) +X(I2) +X(I3) +X(I4) +X(L) +X(LD) +X(LJ) +X(LK) +X(LO) +X(LX) +X(R) + +// BFF +X(BFF) +X(C) X(I) -X(EN) +X(J) +X(K) X(O) -X(IOB) -X(PAD) -X(INIT) +X(P) +X(S) + +// BFR +X(BFR) +//X(I) +//X(O) + +// BGC +X(BGC) +X(AI1) +X(AI2) +X(AI3) +X(AI4) +X(AI5) +X(AI6) +X(AO1) +X(AO2) +X(AO3) +X(AO4) +X(AO5) +X(AO6) +X(BI1) +X(BI2) +X(BI3) +X(BI4) +X(BI5) +X(BI6) +X(BO1) +X(BO2) +X(BO3) +X(BO4) +X(BO5) +X(BO6) + +// CDC +X(CDC) +X(ADRSTI) +X(ADRSTO) +//X(AI1) +//X(AI2) +//X(AI3) +//X(AI4) +//X(AI5) +//X(AI6) +//X(AO1) +//X(AO2) +//X(AO3) +//X(AO4) +//X(AO5) +//X(AO6) +X(ASRSTI) +X(ASRSTO) +X(BDRSTI) +X(BDRSTO) +//X(BI1) +//X(BI2) +//X(BI3) +//X(BI4) +//X(BI5) +//X(BI6) +//X(BO1) +//X(BO2) +//X(BO3) +//X(BO4) +//X(BO5) +//X(BO6) +X(BSRSTI) +X(BSRSTO) +X(CK1) +X(CK2) + +// CRX +X(CRX) +X(ALIGN_E_I) +X(ALIGN_O) +X(ALIGN_S_I) +X(BUF_R_I) +X(BUSY_O) +X(CH_A_O1) +X(CH_A_O2) +X(CH_A_O3) +X(CH_A_O4) +X(CH_A_O5) +X(CH_A_O6) +X(CH_A_O7) +X(CH_A_O8) +X(CH_COM_O1) +X(CH_COM_O2) +X(CH_COM_O3) +X(CH_COM_O4) +X(CH_COM_O5) +X(CH_COM_O6) +X(CH_COM_O7) +X(CH_COM_O8) +X(CH_F_O1) +X(CH_F_O2) +X(CH_F_O3) +X(CH_F_O4) +X(CH_F_O5) +X(CH_F_O6) +X(CH_F_O7) +X(CH_F_O8) +X(CH_K_O1) +X(CH_K_O2) +X(CH_K_O3) +X(CH_K_O4) +X(CH_K_O5) +X(CH_K_O6) +X(CH_K_O7) +X(CH_K_O8) +X(DATA_O1) +X(DATA_O10) +X(DATA_O11) +X(DATA_O12) +X(DATA_O13) +X(DATA_O14) +X(DATA_O15) +X(DATA_O16) +X(DATA_O17) +X(DATA_O18) +X(DATA_O19) +X(DATA_O2) +X(DATA_O20) +X(DATA_O21) +X(DATA_O22) +X(DATA_O23) +X(DATA_O24) +X(DATA_O25) +X(DATA_O26) +X(DATA_O27) +X(DATA_O28) +X(DATA_O29) +X(DATA_O3) +X(DATA_O30) +X(DATA_O31) +X(DATA_O32) +X(DATA_O33) +X(DATA_O34) +X(DATA_O35) +X(DATA_O36) +X(DATA_O37) +X(DATA_O38) +X(DATA_O39) +X(DATA_O4) +X(DATA_O40) +X(DATA_O41) +X(DATA_O42) +X(DATA_O43) +X(DATA_O44) +X(DATA_O45) +X(DATA_O46) +X(DATA_O47) +X(DATA_O48) +X(DATA_O49) +X(DATA_O5) +X(DATA_O50) +X(DATA_O51) +X(DATA_O52) +X(DATA_O53) +X(DATA_O54) +X(DATA_O55) +X(DATA_O56) +X(DATA_O57) +X(DATA_O58) +X(DATA_O59) +X(DATA_O6) +X(DATA_O60) +X(DATA_O61) +X(DATA_O62) +X(DATA_O63) +X(DATA_O64) +X(DATA_O7) +X(DATA_O8) +X(DATA_O9) +X(DBG_S_I1) +X(DBG_S_I2) +X(DBG_S_I3) +X(DEC_E_I) +X(DSCR_E_I) +X(D_ERR_O1) +X(D_ERR_O2) +X(D_ERR_O3) +X(D_ERR_O4) +X(D_ERR_O5) +X(D_ERR_O6) +X(D_ERR_O7) +X(D_ERR_O8) +X(LINK) +X(LL_FLOCK_O) +X(LL_SLOCK_O) +X(LOS_O) +X(MEYE_RST_I) +X(NIT_O1) +X(NIT_O2) +X(NIT_O3) +X(NIT_O4) +X(NIT_O5) +X(NIT_O6) +X(NIT_O7) +X(NIT_O8) +X(OVS_BS_I1) +X(OVS_BS_I2) +X(PLL_LOCKT_O) +X(PLL_LOCK_O) +X(PMA_RSTN_I) +X(PWDN_N_I) +X(REP_E_I) +X(RST_N_I) +X(TST_O1) +X(TST_O2) +X(TST_O3) +X(TST_O4) +X(TST_O5) +X(TST_O6) +X(TST_O7) +X(TST_O8) +X(VREALIGN_O) + +// CSC +X(CSC) +//X(C) +//X(I) +//X(J) +//X(K) +//X(O) +//X(P) +//X(S) + +// CTX +X(CTX) +//X(BUSY_O) +X(CH_K_I1) +X(CH_K_I2) +X(CH_K_I3) +X(CH_K_I4) +X(CH_K_I5) +X(CH_K_I6) +X(CH_K_I7) +X(CH_K_I8) +X(CLK_E_I) +X(CLK_O) +X(DATA_I1) +X(DATA_I10) +X(DATA_I11) +X(DATA_I12) +X(DATA_I13) +X(DATA_I14) +X(DATA_I15) +X(DATA_I16) +X(DATA_I17) +X(DATA_I18) +X(DATA_I19) +X(DATA_I2) +X(DATA_I20) +X(DATA_I21) +X(DATA_I22) +X(DATA_I23) +X(DATA_I24) +X(DATA_I25) +X(DATA_I26) +X(DATA_I27) +X(DATA_I28) +X(DATA_I29) +X(DATA_I3) +X(DATA_I30) +X(DATA_I31) +X(DATA_I32) +X(DATA_I33) +X(DATA_I34) +X(DATA_I35) +X(DATA_I36) +X(DATA_I37) +X(DATA_I38) +X(DATA_I39) +X(DATA_I4) +X(DATA_I40) +X(DATA_I41) +X(DATA_I42) +X(DATA_I43) +X(DATA_I44) +X(DATA_I45) +X(DATA_I46) +X(DATA_I47) +X(DATA_I48) +X(DATA_I49) +X(DATA_I5) +X(DATA_I50) +X(DATA_I51) +X(DATA_I52) +X(DATA_I53) +X(DATA_I54) +X(DATA_I55) +X(DATA_I56) +X(DATA_I57) +X(DATA_I58) +X(DATA_I59) +X(DATA_I6) +X(DATA_I60) +X(DATA_I61) +X(DATA_I62) +X(DATA_I63) +X(DATA_I64) +X(DATA_I7) +X(DATA_I8) +X(DATA_I9) +X(ENC_E_I1) +X(ENC_E_I2) +X(ENC_E_I3) +X(ENC_E_I4) +X(ENC_E_I5) +X(ENC_E_I6) +X(ENC_E_I7) +X(ENC_E_I8) +X(EOF_I1) +X(EOF_I2) +X(EOF_I3) +X(EOF_I4) +X(EOF_I5) +X(EOF_I6) +X(EOF_I7) +X(EOF_I8) +X(EOMF_I1) +X(EOMF_I2) +X(EOMF_I3) +X(EOMF_I4) +X(EOMF_I5) +X(EOMF_I6) +X(EOMF_I7) +X(EOMF_I8) +X(INV_K_O) +//X(LINK) +//X(PWDN_N_I) +//X(REP_E_I) +//X(RST_N_I) +X(SCR_E_I1) +X(SCR_E_I2) +X(SCR_E_I3) +X(SCR_E_I4) +X(SCR_E_I5) +X(SCR_E_I6) +X(SCR_E_I7) +X(SCR_E_I8) + +// CY +X(CY) +X(A1) +X(A2) +X(A3) +X(A4) +X(B1) +X(B2) +X(B3) +X(B4) +X(CI) +X(CO) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +X(O1) +X(O2) +X(O3) +X(O4) +X(S1) +X(S2) +X(S3) +X(S4) + +// DDE +X(DDE) +//X(ADRSTI) +//X(ADRSTO) +//X(AI1) +//X(AI2) +//X(AI3) +//X(AI4) +//X(AI5) +//X(AI6) +//X(AO1) +//X(AO2) +//X(AO3) +//X(AO4) +//X(AO5) +//X(AO6) +//X(BDRSTI) +//X(BDRSTO) +//X(BI1) +//X(BI2) +//X(BI3) +//X(BI4) +//X(BI5) +//X(BI6) +//X(BO1) +//X(BO2) +//X(BO3) +//X(BO4) +//X(BO5) +//X(BO6) +//X(CK1) +//X(CK2) + +// DDFR +X(DDFR) +//X(CK) +X(CKF) +//X(I) +//X(I2) +//X(L) +//X(O) +//X(O2) +//X(R) + +// DFF +X(DFF) +//X(C) +//X(CK) +//X(I) +//X(J) +//X(K) +//X(L) +//X(O) +//X(P) +//X(R) +//X(S) + +// DFR +X(DFR) +//X(CK) +//X(I) +//X(L) +//X(O) +//X(R) + +// DSP +X(DSP) +//X(A1) +X(A10) +X(A11) +X(A12) +X(A13) +X(A14) +X(A15) +X(A16) +X(A17) +X(A18) +X(A19) +//X(A2) +X(A20) +X(A21) +X(A22) +X(A23) +X(A24) +//X(A3) +//X(A4) +X(A5) +X(A6) +X(A7) +X(A8) +X(A9) +//X(B1) +X(B10) +X(B11) +X(B12) +X(B13) +X(B14) +X(B15) +X(B16) +X(B17) +X(B18) +//X(B2) +//X(B3) +//X(B4) +X(B5) +X(B6) +X(B7) +X(B8) +X(B9) +X(C1) +X(C10) +X(C11) +X(C12) +X(C13) +X(C14) +X(C15) +X(C16) +X(C17) +X(C18) +X(C19) +X(C2) +X(C20) +X(C21) +X(C22) +X(C23) +X(C24) +X(C25) +X(C26) +X(C27) +X(C28) +X(C29) +X(C3) +X(C30) +X(C31) +X(C32) +X(C33) +X(C34) +X(C35) +X(C36) +X(C4) +X(C5) +X(C6) +X(C7) +X(C8) +X(C9) +X(CAI1) +X(CAI10) +X(CAI11) +X(CAI12) +X(CAI13) +X(CAI14) +X(CAI15) +X(CAI16) +X(CAI17) +X(CAI18) +X(CAI19) +X(CAI2) +X(CAI20) +X(CAI21) +X(CAI22) +X(CAI23) +X(CAI24) +X(CAI3) +X(CAI4) +X(CAI5) +X(CAI6) +X(CAI7) +X(CAI8) +X(CAI9) +X(CAO1) +X(CAO10) +X(CAO11) +X(CAO12) +X(CAO13) +X(CAO14) +X(CAO15) +X(CAO16) +X(CAO17) +X(CAO18) +X(CAO19) +X(CAO2) +X(CAO20) +X(CAO21) +X(CAO22) +X(CAO23) +X(CAO24) +X(CAO3) +X(CAO4) +X(CAO5) +X(CAO6) +X(CAO7) +X(CAO8) +X(CAO9) +X(CBI1) +X(CBI10) +X(CBI11) +X(CBI12) +X(CBI13) +X(CBI14) +X(CBI15) +X(CBI16) +X(CBI17) +X(CBI18) +X(CBI2) +X(CBI3) +X(CBI4) +X(CBI5) +X(CBI6) +X(CBI7) +X(CBI8) +X(CBI9) +X(CBO1) +X(CBO10) +X(CBO11) +X(CBO12) +X(CBO13) +X(CBO14) +X(CBO15) +X(CBO16) +X(CBO17) +X(CBO18) +X(CBO2) +X(CBO3) +X(CBO4) +X(CBO5) +X(CBO6) +X(CBO7) +X(CBO8) +X(CBO9) +X(CCI) +X(CCO) +//X(CI) +//X(CK) +X(CO43) +X(CO57) +X(CZI1) +X(CZI10) +X(CZI11) +X(CZI12) +X(CZI13) +X(CZI14) +X(CZI15) +X(CZI16) +X(CZI17) +X(CZI18) +X(CZI19) +X(CZI2) +X(CZI20) +X(CZI21) +X(CZI22) +X(CZI23) +X(CZI24) +X(CZI25) +X(CZI26) +X(CZI27) +X(CZI28) +X(CZI29) +X(CZI3) +X(CZI30) +X(CZI31) +X(CZI32) +X(CZI33) +X(CZI34) +X(CZI35) +X(CZI36) +X(CZI37) +X(CZI38) +X(CZI39) +X(CZI4) +X(CZI40) +X(CZI41) +X(CZI42) +X(CZI43) +X(CZI44) +X(CZI45) +X(CZI46) +X(CZI47) +X(CZI48) +X(CZI49) +X(CZI5) +X(CZI50) +X(CZI51) +X(CZI52) +X(CZI53) +X(CZI54) +X(CZI55) +X(CZI56) +X(CZI6) +X(CZI7) +X(CZI8) +X(CZI9) +X(CZO1) +X(CZO10) +X(CZO11) +X(CZO12) +X(CZO13) +X(CZO14) +X(CZO15) +X(CZO16) +X(CZO17) +X(CZO18) +X(CZO19) +X(CZO2) +X(CZO20) +X(CZO21) +X(CZO22) +X(CZO23) +X(CZO24) +X(CZO25) +X(CZO26) +X(CZO27) +X(CZO28) +X(CZO29) +X(CZO3) +X(CZO30) +X(CZO31) +X(CZO32) +X(CZO33) +X(CZO34) +X(CZO35) +X(CZO36) +X(CZO37) +X(CZO38) +X(CZO39) +X(CZO4) +X(CZO40) +X(CZO41) +X(CZO42) +X(CZO43) +X(CZO44) +X(CZO45) +X(CZO46) +X(CZO47) +X(CZO48) +X(CZO49) +X(CZO5) +X(CZO50) +X(CZO51) +X(CZO52) +X(CZO53) +X(CZO54) +X(CZO55) +X(CZO56) +X(CZO6) +X(CZO7) +X(CZO8) +X(CZO9) +X(D1) +X(D10) +X(D11) +X(D12) +X(D13) +X(D14) +X(D15) +X(D16) +X(D17) +X(D18) +X(D2) +X(D3) +X(D4) +X(D5) +X(D6) +X(D7) +X(D8) +X(D9) +X(OVF) +//X(R) +X(RESERVED) +X(RZ) +X(WE) +X(WEZ) +X(Z1) +X(Z10) +X(Z11) +X(Z12) +X(Z13) +X(Z14) +X(Z15) +X(Z16) +X(Z17) +X(Z18) +X(Z19) +X(Z2) +X(Z20) +X(Z21) +X(Z22) +X(Z23) +X(Z24) +X(Z25) +X(Z26) +X(Z27) +X(Z28) +X(Z29) +X(Z3) +X(Z30) +X(Z31) +X(Z32) +X(Z33) +X(Z34) +X(Z35) +X(Z36) +X(Z37) +X(Z38) +X(Z39) +X(Z4) +X(Z40) +X(Z41) +X(Z42) +X(Z43) +X(Z44) +X(Z45) +X(Z46) +X(Z47) +X(Z48) +X(Z49) +X(Z5) +X(Z50) +X(Z51) +X(Z52) +X(Z53) +X(Z54) +X(Z55) +X(Z56) +X(Z6) +X(Z7) +X(Z8) +X(Z9) + +// FCI +X(FCI) +//X(I) +//X(O) + +// FCO +X(FCO) +//X(I) +//X(O) + +// FIFO +X(FIFO) +//X(I1) +X(I10) +X(I11) +X(I12) +X(I13) +X(I14) +X(I15) +X(I16) +X(I17) +X(I18) +//X(I2) +//X(I3) +//X(I4) +X(I5) +X(I6) +X(I7) +X(I8) +X(I9) +//X(O1) +X(O10) +X(O11) +X(O12) +X(O13) +X(O14) +X(O15) +X(O16) +X(O17) +X(O18) +//X(O2) +//X(O3) +//X(O4) +X(O5) +X(O6) +X(O7) +X(O8) +X(O9) +X(RAI1) +X(RAI2) +X(RAI3) +X(RAI4) +X(RAI5) +X(RAI6) +X(RAO1) +X(RAO2) +X(RAO3) +X(RAO4) +X(RAO5) +X(RAO6) +X(RCK) +X(REQ) +X(RRSTI1) +X(RRSTI2) +X(RRSTO) +X(WAI1) +X(WAI2) +X(WAI3) +X(WAI4) +X(WAI5) +X(WAI6) +X(WAO1) +X(WAO2) +X(WAO3) +X(WAO4) +X(WAO5) +X(WAO6) +X(WCK) +//X(WE) +X(WEA) +X(WEQ) +X(WRSTI1) +X(WRSTI2) +X(WRSTO) + +// GBC +X(GBC) +//X(AI1) +//X(AI2) +//X(AI3) +//X(AI4) +//X(AI5) +//X(AI6) +//X(AO1) +//X(AO2) +//X(AO3) +//X(AO4) +//X(AO5) +//X(AO6) +//X(BI1) +//X(BI2) +//X(BI3) +//X(BI4) +//X(BI5) +//X(BI6) +//X(BO1) +//X(BO2) +//X(BO3) +//X(BO4) +//X(BO5) +//X(BO6) + +// GCI +X(GCI) +//X(I) +//X(O) + +// GCK +X(GCK) +X(CMD) +X(SI1) +X(SI2) +X(SO) + +// GEA +X(GEA) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +X(I19) +//X(I2) +X(I20) +X(I21) +X(I22) +X(I23) +X(I24) +X(I25) +X(I26) +X(I27) +X(I28) +X(I29) +//X(I3) +X(I30) +X(I31) +X(I32) +X(I33) +X(I34) +X(I35) +X(I36) +X(I37) +X(I38) +X(I39) +//X(I4) +X(I40) +X(I41) +X(I42) +X(I43) +X(I44) +X(I45) +X(I46) +X(I47) +X(I48) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O2) +//X(O3) +//X(O4) + +// GEB +X(GEB) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) + +// GSO +X(GSO) +//X(I) +//X(O) + +// HEE +X(HEE) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// HSS +X(HSS) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// IOM +X(IOM) +X(AL1D) +X(AL1T) +X(AL2D) +X(AL2T) +X(AL3D) +X(AL3T) +X(ALCK1) +X(ALCK2) +X(ALCK3) +X(CA1D1) +X(CA1D2) +X(CA1D3) +X(CA1D4) +X(CA1D5) +X(CA1D6) +X(CA1N1) +X(CA1N2) +X(CA1N3) +X(CA1N4) +X(CA1P1) +X(CA1P2) +X(CA1P3) +X(CA1P4) +X(CA1T1) +X(CA1T2) +X(CA1T3) +X(CA1T4) +X(CA2D1) +X(CA2D2) +X(CA2D3) +X(CA2D4) +X(CA2D5) +X(CA2D6) +X(CA2N1) +X(CA2N2) +X(CA2N3) +X(CA2N4) +X(CA2P1) +X(CA2P2) +X(CA2P3) +X(CA2P4) +X(CA2T1) +X(CA2T2) +X(CA2T3) +X(CA2T4) +X(CCK) +X(CKO1) +X(CKO2) +X(DCL) +X(DCRN) +X(DQ1CI1) +X(DQ1CI2) +X(DQ1CI3) +X(DQ1CI4) +X(DQ1CI5) +X(DQ1CI6) +X(DQ1CI7) +X(DQ1CI8) +X(DQ2CI1) +X(DQ2CI2) +X(DQ2CI3) +X(DQ2CI4) +X(DQ2CI5) +X(DQ2CI6) +X(DQ2CI7) +X(DQ2CI8) +X(DQ3CI1) +X(DQ3CI2) +X(DQ3CI3) +X(DQ3CI4) +X(DQ3CI5) +X(DQ3CI6) +X(DQ3CI7) +X(DQ3CI8) +X(DQS1CI1) +X(DQS1CI2) +X(DQS1CI3) +X(DQS1CI4) +X(DQS1CI5) +X(DQS1CI6) +X(DQS1CI7) +X(DQS1CI8) +X(DQS2CI1) +X(DQS2CI2) +X(DQS2CI3) +X(DQS2CI4) +X(DQS2CI5) +X(DQS2CI6) +X(DQS2CI7) +X(DQS2CI8) +X(DQS3CI1) +X(DQS3CI2) +X(DQS3CI3) +X(DQS3CI4) +X(DQS3CI5) +X(DQS3CI6) +X(DQS3CI7) +X(DQS3CI8) +X(DRA1) +X(DRA2) +X(DRA3) +X(DRA4) +X(DRCCSN) +X(DRDPA1CSN) +X(DRDPA2CSN) +X(DRDPA3CSN) +X(DRE) +X(DRI1) +X(DRI1CSN) +X(DRI2) +X(DRI2CSN) +X(DRI3) +X(DRI3CSN) +X(DRI4) +X(DRI5) +X(DRI6) +X(DRO1) +X(DRO1CSN) +X(DRO2) +X(DRO2CSN) +X(DRO3) +X(DRO3CSN) +X(DRO4) +X(DRO5) +X(DRO6) +X(DRWDS) +X(DRWEN) +X(FA1) +X(FA2) +X(FA3) +X(FA4) +X(FA5) +X(FA6) +X(FCK1) +X(FCK2) +X(FDCK) +X(FLD) +X(FLG) +X(FZ) +X(LD1RN) +X(LD2RN) +X(LD3RN) +X(LDSCK1) +X(LDSCK2) +X(LDSCK3) +X(LE) +X(P10CI1) +X(P10CL) +X(P10CO) +X(P10CR) +X(P10CTI) +X(P10CTO) +X(P10EI1) +X(P10EI2) +X(P10EI3) +X(P10EI4) +X(P10EI5) +X(P10EI6) +X(P10EI7) +X(P10EI8) +X(P10EL) +X(P10EO) +X(P10ER) +X(P10RI) +X(P10RL) +X(P10RO1) +X(P10RO2) +X(P10RO3) +X(P10RO4) +X(P10RO5) +X(P10RO6) +X(P10RO7) +X(P10RO8) +X(P10RR) +X(P11CI1) +X(P11CL) +X(P11CO) +X(P11CR) +X(P11CTI) +X(P11CTO) +X(P11EI1) +X(P11EI2) +X(P11EI3) +X(P11EI4) +X(P11EI5) +X(P11EI6) +X(P11EI7) +X(P11EI8) +X(P11EL) +X(P11EO) +X(P11ER) +X(P11RI) +X(P11RL) +X(P11RO1) +X(P11RO2) +X(P11RO3) +X(P11RO4) +X(P11RO5) +X(P11RO6) +X(P11RO7) +X(P11RO8) +X(P11RR) +X(P12CI1) +X(P12CL) +X(P12CO) +X(P12CR) +X(P12CTI) +X(P12CTO) +X(P12EI1) +X(P12EI2) +X(P12EI3) +X(P12EI4) +X(P12EI5) +X(P12EI6) +X(P12EI7) +X(P12EI8) +X(P12EL) +X(P12EO) +X(P12ER) +X(P12RI) +X(P12RL) +X(P12RO1) +X(P12RO2) +X(P12RO3) +X(P12RO4) +X(P12RO5) +X(P12RO6) +X(P12RO7) +X(P12RO8) +X(P12RR) +X(P13CI1) +X(P13CL) +X(P13CO) +X(P13CR) +X(P13CTI) +X(P13CTO) +X(P13EI1) +X(P13EI2) +X(P13EI3) +X(P13EI4) +X(P13EI5) +X(P13EI6) +X(P13EI7) +X(P13EI8) +X(P13EL) +X(P13EO) +X(P13ER) +X(P13RI) +X(P13RL) +X(P13RO1) +X(P13RO2) +X(P13RO3) +X(P13RO4) +X(P13RO5) +X(P13RO6) +X(P13RO7) +X(P13RO8) +X(P13RR) +X(P14CI1) +X(P14CL) +X(P14CO) +X(P14CR) +X(P14CTI) +X(P14CTO) +X(P14EI1) +X(P14EI2) +X(P14EI3) +X(P14EI4) +X(P14EI5) +X(P14EI6) +X(P14EI7) +X(P14EI8) +X(P14EL) +X(P14EO) +X(P14ER) +X(P14RI) +X(P14RL) +X(P14RO1) +X(P14RO2) +X(P14RO3) +X(P14RO4) +X(P14RO5) +X(P14RO6) +X(P14RO7) +X(P14RO8) +X(P14RR) +X(P15CI1) +X(P15CL) +X(P15CO) +X(P15CR) +X(P15CTI) +X(P15CTO) +X(P15EI1) +X(P15EI2) +X(P15EI3) +X(P15EI4) +X(P15EI5) +X(P15EI6) +X(P15EI7) +X(P15EI8) +X(P15EL) +X(P15EO) +X(P15ER) +X(P15RI) +X(P15RL) +X(P15RO1) +X(P15RO2) +X(P15RO3) +X(P15RO4) +X(P15RO5) +X(P15RO6) +X(P15RO7) +X(P15RO8) +X(P15RR) +X(P16CI1) +X(P16CL) +X(P16CO) +X(P16CR) +X(P16CTI) +X(P16CTO) +X(P16EI1) +X(P16EI2) +X(P16EI3) +X(P16EI4) +X(P16EI5) +X(P16EI6) +X(P16EI7) +X(P16EI8) +X(P16EL) +X(P16EO) +X(P16ER) +X(P16RI) +X(P16RL) +X(P16RO1) +X(P16RO2) +X(P16RO3) +X(P16RO4) +X(P16RO5) +X(P16RO6) +X(P16RO7) +X(P16RO8) +X(P16RR) +X(P17CI1) +X(P17CL) +X(P17CO) +X(P17CR) +X(P17CTI) +X(P17CTO) +X(P17EI1) +X(P17EI2) +X(P17EI3) +X(P17EI4) +X(P17EI5) +X(P17EI6) +X(P17EI7) +X(P17EI8) +X(P17EL) +X(P17EO) +X(P17ER) +X(P17RI) +X(P17RL) +X(P17RO1) +X(P17RO2) +X(P17RO3) +X(P17RO4) +X(P17RO5) +X(P17RO6) +X(P17RO7) +X(P17RO8) +X(P17RR) +X(P18CI1) +X(P18CL) +X(P18CO) +X(P18CR) +X(P18CTI) +X(P18CTO) +X(P18EI1) +X(P18EI2) +X(P18EI3) +X(P18EI4) +X(P18EI5) +X(P18EI6) +X(P18EI7) +X(P18EI8) +X(P18EL) +X(P18EO) +X(P18ER) +X(P18RI) +X(P18RL) +X(P18RO1) +X(P18RO2) +X(P18RO3) +X(P18RO4) +X(P18RO5) +X(P18RO6) +X(P18RO7) +X(P18RO8) +X(P18RR) +X(P19CI1) +X(P19CL) +X(P19CO) +X(P19CR) +X(P19CTI) +X(P19CTO) +X(P19EI1) +X(P19EI2) +X(P19EI3) +X(P19EI4) +X(P19EI5) +X(P19EI6) +X(P19EI7) +X(P19EI8) +X(P19EL) +X(P19EO) +X(P19ER) +X(P19RI) +X(P19RL) +X(P19RO1) +X(P19RO2) +X(P19RO3) +X(P19RO4) +X(P19RO5) +X(P19RO6) +X(P19RO7) +X(P19RO8) +X(P19RR) +X(P1CI1) +X(P1CL) +X(P1CO) +X(P1CR) +X(P1CTI) +X(P1CTO) +X(P1EI1) +X(P1EI2) +X(P1EI3) +X(P1EI4) +X(P1EI5) +X(P1EI6) +X(P1EI7) +X(P1EI8) +X(P1EL) +X(P1EO) +X(P1ER) +X(P1RI) +X(P1RL) +X(P1RO1) +X(P1RO2) +X(P1RO3) +X(P1RO4) +X(P1RO5) +X(P1RO6) +X(P1RO7) +X(P1RO8) +X(P1RR) +X(P20CI1) +X(P20CL) +X(P20CO) +X(P20CR) +X(P20CTI) +X(P20CTO) +X(P20EI1) +X(P20EI2) +X(P20EI3) +X(P20EI4) +X(P20EI5) +X(P20EI6) +X(P20EI7) +X(P20EI8) +X(P20EL) +X(P20EO) +X(P20ER) +X(P20RI) +X(P20RL) +X(P20RO1) +X(P20RO2) +X(P20RO3) +X(P20RO4) +X(P20RO5) +X(P20RO6) +X(P20RO7) +X(P20RO8) +X(P20RR) +X(P21CI1) +X(P21CL) +X(P21CO) +X(P21CR) +X(P21CTI) +X(P21CTO) +X(P21EI1) +X(P21EI2) +X(P21EI3) +X(P21EI4) +X(P21EI5) +X(P21EI6) +X(P21EI7) +X(P21EI8) +X(P21EL) +X(P21EO) +X(P21ER) +X(P21RI) +X(P21RL) +X(P21RO1) +X(P21RO2) +X(P21RO3) +X(P21RO4) +X(P21RO5) +X(P21RO6) +X(P21RO7) +X(P21RO8) +X(P21RR) +X(P22CI1) +X(P22CL) +X(P22CO) +X(P22CR) +X(P22CTI) +X(P22CTO) +X(P22EI1) +X(P22EI2) +X(P22EI3) +X(P22EI4) +X(P22EI5) +X(P22EI6) +X(P22EI7) +X(P22EI8) +X(P22EL) +X(P22EO) +X(P22ER) +X(P22RI) +X(P22RL) +X(P22RO1) +X(P22RO2) +X(P22RO3) +X(P22RO4) +X(P22RO5) +X(P22RO6) +X(P22RO7) +X(P22RO8) +X(P22RR) +X(P23CI1) +X(P23CL) +X(P23CO) +X(P23CR) +X(P23CTI) +X(P23CTO) +X(P23EI1) +X(P23EI2) +X(P23EI3) +X(P23EI4) +X(P23EI5) +X(P23EI6) +X(P23EI7) +X(P23EI8) +X(P23EL) +X(P23EO) +X(P23ER) +X(P23RI) +X(P23RL) +X(P23RO1) +X(P23RO2) +X(P23RO3) +X(P23RO4) +X(P23RO5) +X(P23RO6) +X(P23RO7) +X(P23RO8) +X(P23RR) +X(P24CI1) +X(P24CL) +X(P24CO) +X(P24CR) +X(P24CTI) +X(P24CTO) +X(P24EI1) +X(P24EI2) +X(P24EI3) +X(P24EI4) +X(P24EI5) +X(P24EI6) +X(P24EI7) +X(P24EI8) +X(P24EL) +X(P24EO) +X(P24ER) +X(P24RI) +X(P24RL) +X(P24RO1) +X(P24RO2) +X(P24RO3) +X(P24RO4) +X(P24RO5) +X(P24RO6) +X(P24RO7) +X(P24RO8) +X(P24RR) +X(P25CI1) +X(P25CL) +X(P25CO) +X(P25CR) +X(P25CTI) +X(P25CTO) +X(P25EI1) +X(P25EI2) +X(P25EI3) +X(P25EI4) +X(P25EI5) +X(P25EI6) +X(P25EI7) +X(P25EI8) +X(P25EL) +X(P25EO) +X(P25ER) +X(P25RI) +X(P25RL) +X(P25RO1) +X(P25RO2) +X(P25RO3) +X(P25RO4) +X(P25RO5) +X(P25RO6) +X(P25RO7) +X(P25RO8) +X(P25RR) +X(P26CI1) +X(P26CL) +X(P26CO) +X(P26CR) +X(P26CTI) +X(P26CTO) +X(P26EI1) +X(P26EI2) +X(P26EI3) +X(P26EI4) +X(P26EI5) +X(P26EI6) +X(P26EI7) +X(P26EI8) +X(P26EL) +X(P26EO) +X(P26ER) +X(P26RI) +X(P26RL) +X(P26RO1) +X(P26RO2) +X(P26RO3) +X(P26RO4) +X(P26RO5) +X(P26RO6) +X(P26RO7) +X(P26RO8) +X(P26RR) +X(P27CI1) +X(P27CL) +X(P27CO) +X(P27CR) +X(P27CTI) +X(P27CTO) +X(P27EI1) +X(P27EI2) +X(P27EI3) +X(P27EI4) +X(P27EI5) +X(P27EI6) +X(P27EI7) +X(P27EI8) +X(P27EL) +X(P27EO) +X(P27ER) +X(P27RI) +X(P27RL) +X(P27RO1) +X(P27RO2) +X(P27RO3) +X(P27RO4) +X(P27RO5) +X(P27RO6) +X(P27RO7) +X(P27RO8) +X(P27RR) +X(P28CI1) +X(P28CL) +X(P28CO) +X(P28CR) +X(P28CTI) +X(P28CTO) +X(P28EI1) +X(P28EI2) +X(P28EI3) +X(P28EI4) +X(P28EI5) +X(P28EI6) +X(P28EI7) +X(P28EI8) +X(P28EL) +X(P28EO) +X(P28ER) +X(P28RI) +X(P28RL) +X(P28RO1) +X(P28RO2) +X(P28RO3) +X(P28RO4) +X(P28RO5) +X(P28RO6) +X(P28RO7) +X(P28RO8) +X(P28RR) +X(P29CI1) +X(P29CL) +X(P29CO) +X(P29CR) +X(P29CTI) +X(P29CTO) +X(P29EI1) +X(P29EI2) +X(P29EI3) +X(P29EI4) +X(P29EI5) +X(P29EI6) +X(P29EI7) +X(P29EI8) +X(P29EL) +X(P29EO) +X(P29ER) +X(P29RI) +X(P29RL) +X(P29RO1) +X(P29RO2) +X(P29RO3) +X(P29RO4) +X(P29RO5) +X(P29RO6) +X(P29RO7) +X(P29RO8) +X(P29RR) +X(P2CI1) +X(P2CL) +X(P2CO) +X(P2CR) +X(P2CTI) +X(P2CTO) +X(P2EI1) +X(P2EI2) +X(P2EI3) +X(P2EI4) +X(P2EI5) +X(P2EI6) +X(P2EI7) +X(P2EI8) +X(P2EL) +X(P2EO) +X(P2ER) +X(P2RI) +X(P2RL) +X(P2RO1) +X(P2RO2) +X(P2RO3) +X(P2RO4) +X(P2RO5) +X(P2RO6) +X(P2RO7) +X(P2RO8) +X(P2RR) +X(P30CI1) +X(P30CL) +X(P30CO) +X(P30CR) +X(P30CTI) +X(P30CTO) +X(P30EI1) +X(P30EI2) +X(P30EI3) +X(P30EI4) +X(P30EI5) +X(P30EI6) +X(P30EI7) +X(P30EI8) +X(P30EL) +X(P30EO) +X(P30ER) +X(P30RI) +X(P30RL) +X(P30RO1) +X(P30RO2) +X(P30RO3) +X(P30RO4) +X(P30RO5) +X(P30RO6) +X(P30RO7) +X(P30RO8) +X(P30RR) +X(P31CI1) +X(P31CL) +X(P31CO) +X(P31CR) +X(P31CTI) +X(P31CTO) +X(P31EI1) +X(P31EI2) +X(P31EI3) +X(P31EI4) +X(P31EI5) +X(P31EI6) +X(P31EI7) +X(P31EI8) +X(P31EL) +X(P31EO) +X(P31ER) +X(P31RI) +X(P31RL) +X(P31RO1) +X(P31RO2) +X(P31RO3) +X(P31RO4) +X(P31RO5) +X(P31RO6) +X(P31RO7) +X(P31RO8) +X(P31RR) +X(P32CI1) +X(P32CL) +X(P32CO) +X(P32CR) +X(P32CTI) +X(P32CTO) +X(P32EI1) +X(P32EI2) +X(P32EI3) +X(P32EI4) +X(P32EI5) +X(P32EI6) +X(P32EI7) +X(P32EI8) +X(P32EL) +X(P32EO) +X(P32ER) +X(P32RI) +X(P32RL) +X(P32RO1) +X(P32RO2) +X(P32RO3) +X(P32RO4) +X(P32RO5) +X(P32RO6) +X(P32RO7) +X(P32RO8) +X(P32RR) +X(P33CI1) +X(P33CL) +X(P33CO) +X(P33CR) +X(P33CTI) +X(P33CTO) +X(P33EI1) +X(P33EI2) +X(P33EI3) +X(P33EI4) +X(P33EI5) +X(P33EI6) +X(P33EI7) +X(P33EI8) +X(P33EL) +X(P33EO) +X(P33ER) +X(P33RI) +X(P33RL) +X(P33RO1) +X(P33RO2) +X(P33RO3) +X(P33RO4) +X(P33RO5) +X(P33RO6) +X(P33RO7) +X(P33RO8) +X(P33RR) +X(P34CI1) +X(P34CL) +X(P34CO) +X(P34CR) +X(P34CTI) +X(P34CTO) +X(P34EI1) +X(P34EI2) +X(P34EI3) +X(P34EI4) +X(P34EI5) +X(P34EI6) +X(P34EI7) +X(P34EI8) +X(P34EL) +X(P34EO) +X(P34ER) +X(P34RI) +X(P34RL) +X(P34RO1) +X(P34RO2) +X(P34RO3) +X(P34RO4) +X(P34RO5) +X(P34RO6) +X(P34RO7) +X(P34RO8) +X(P34RR) +X(P3CI1) +X(P3CL) +X(P3CO) +X(P3CR) +X(P3CTI) +X(P3CTO) +X(P3EI1) +X(P3EI2) +X(P3EI3) +X(P3EI4) +X(P3EI5) +X(P3EI6) +X(P3EI7) +X(P3EI8) +X(P3EL) +X(P3EO) +X(P3ER) +X(P3RI) +X(P3RL) +X(P3RO1) +X(P3RO2) +X(P3RO3) +X(P3RO4) +X(P3RO5) +X(P3RO6) +X(P3RO7) +X(P3RO8) +X(P3RR) +X(P4CI1) +X(P4CL) +X(P4CO) +X(P4CR) +X(P4CTI) +X(P4CTO) +X(P4EI1) +X(P4EI2) +X(P4EI3) +X(P4EI4) +X(P4EI5) +X(P4EI6) +X(P4EI7) +X(P4EI8) +X(P4EL) +X(P4EO) +X(P4ER) +X(P4RI) +X(P4RL) +X(P4RO1) +X(P4RO2) +X(P4RO3) +X(P4RO4) +X(P4RO5) +X(P4RO6) +X(P4RO7) +X(P4RO8) +X(P4RR) +X(P5CI1) +X(P5CL) +X(P5CO) +X(P5CR) +X(P5CTI) +X(P5CTO) +X(P5EI1) +X(P5EI2) +X(P5EI3) +X(P5EI4) +X(P5EI5) +X(P5EI6) +X(P5EI7) +X(P5EI8) +X(P5EL) +X(P5EO) +X(P5ER) +X(P5RI) +X(P5RL) +X(P5RO1) +X(P5RO2) +X(P5RO3) +X(P5RO4) +X(P5RO5) +X(P5RO6) +X(P5RO7) +X(P5RO8) +X(P5RR) +X(P6CI1) +X(P6CL) +X(P6CO) +X(P6CR) +X(P6CTI) +X(P6CTO) +X(P6EI1) +X(P6EI2) +X(P6EI3) +X(P6EI4) +X(P6EI5) +X(P6EI6) +X(P6EI7) +X(P6EI8) +X(P6EL) +X(P6EO) +X(P6ER) +X(P6RI) +X(P6RL) +X(P6RO1) +X(P6RO2) +X(P6RO3) +X(P6RO4) +X(P6RO5) +X(P6RO6) +X(P6RO7) +X(P6RO8) +X(P6RR) +X(P7CI1) +X(P7CL) +X(P7CO) +X(P7CR) +X(P7CTI) +X(P7CTO) +X(P7EI1) +X(P7EI2) +X(P7EI3) +X(P7EI4) +X(P7EI5) +X(P7EI6) +X(P7EI7) +X(P7EI8) +X(P7EL) +X(P7EO) +X(P7ER) +X(P7RI) +X(P7RL) +X(P7RO1) +X(P7RO2) +X(P7RO3) +X(P7RO4) +X(P7RO5) +X(P7RO6) +X(P7RO7) +X(P7RO8) +X(P7RR) +X(P8CI1) +X(P8CL) +X(P8CO) +X(P8CR) +X(P8CTI) +X(P8CTO) +X(P8EI1) +X(P8EI2) +X(P8EI3) +X(P8EI4) +X(P8EI5) +X(P8EI6) +X(P8EI7) +X(P8EI8) +X(P8EL) +X(P8EO) +X(P8ER) +X(P8RI) +X(P8RL) +X(P8RO1) +X(P8RO2) +X(P8RO3) +X(P8RO4) +X(P8RO5) +X(P8RO6) +X(P8RO7) +X(P8RO8) +X(P8RR) +X(P9CI1) +X(P9CL) +X(P9CO) +X(P9CR) +X(P9CTI) +X(P9CTO) +X(P9EI1) +X(P9EI2) +X(P9EI3) +X(P9EI4) +X(P9EI5) +X(P9EI6) +X(P9EI7) +X(P9EI8) +X(P9EL) +X(P9EO) +X(P9ER) +X(P9RI) +X(P9RL) +X(P9RO1) +X(P9RO2) +X(P9RO3) +X(P9RO4) +X(P9RO5) +X(P9RO6) +X(P9RO7) +X(P9RO8) +X(P9RR) +X(SE) +X(SWRX1CK) +X(SWRX2CK) + +// IOP +X(IOP) +//X(C) +//X(I) +//X(O) + +// IOTP +X(IOTP) +//X(C) +//X(I) +X(IO) +//X(O) +X(T) + +// IP +X(IP) +//X(C) +//X(O) + +// ITC +X(ITC) +//X(I) +//X(O) + +// ITP +X(ITP) +//X(C) +//X(IO) +//X(O) +//X(T) + +// ITS +X(ITS) +//X(I) +//X(O) + +// LUT +X(LUT) +X(D) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(J) +//X(K) +//X(O) +X(X) + +// MSM +X(MSM) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I33) +//X(I34) +//X(I35) +//X(I36) +//X(I37) +//X(I38) +//X(I39) +//X(I4) +//X(I40) +//X(I41) +//X(I42) +//X(I43) +//X(I44) +//X(I45) +//X(I46) +//X(I47) +//X(I48) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +X(O19) +//X(O2) +X(O20) +X(O21) +X(O22) +X(O23) +X(O24) +X(O25) +X(O26) +X(O27) +X(O28) +X(O29) +//X(O3) +X(O30) +X(O31) +X(O32) +X(O33) +X(O34) +X(O35) +X(O36) +X(O37) +X(O38) +X(O39) +//X(O4) +X(O40) +X(O41) +X(O42) +X(O43) +X(O44) +X(O45) +X(O46) +X(O47) +X(O48) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// OP +X(OP) +//X(C) +//X(I) + +// OTC +X(OTC) +//X(I) +//X(O) + +// OTP +X(OTP) +//X(C) +//X(I) +//X(IO) +//X(T) + +// OTS +X(OTS) +//X(I) +//X(O) + +// PLL +X(PLL) +X(ARST_CAL) +X(CAL1) +X(CAL2) +X(CAL3) +X(CAL4) +X(CAL5) +X(CAL_LOCKED) +X(CLK_CAL) +X(CLK_CAL_DIV) +X(CLK_DIV1) +X(CLK_DIV2) +X(CLK_DIV3) +X(CLK_DIV4) +X(CLK_DIVD1) +X(CLK_DIVD2) +X(CLK_DIVD3) +X(CLK_DIVD4) +X(CLK_DIVD5) +X(EXT_CAL1) +X(EXT_CAL2) +X(EXT_CAL3) +X(EXT_CAL4) +X(EXT_CAL5) +X(EXT_CAL_LOCKED) +X(FBK) +X(LDFO) +X(OSC) +X(PLL_LOCKED) +X(PLL_LOCKEDA) +//X(R) +X(REF) +X(REFO) +X(VCO) +X(scan_en_i) +X(scan_in_i1) +X(scan_in_i10) +X(scan_in_i11) +X(scan_in_i12) +X(scan_in_i13) +X(scan_in_i14) +X(scan_in_i15) +X(scan_in_i16) +X(scan_in_i17) +X(scan_in_i18) +X(scan_in_i19) +X(scan_in_i2) +X(scan_in_i20) +X(scan_in_i21) +X(scan_in_i22) +X(scan_in_i23) +X(scan_in_i24) +X(scan_in_i25) +X(scan_in_i26) +X(scan_in_i27) +X(scan_in_i28) +X(scan_in_i29) +X(scan_in_i3) +X(scan_in_i30) +X(scan_in_i31) +X(scan_in_i32) +X(scan_in_i33) +X(scan_in_i34) +X(scan_in_i35) +X(scan_in_i36) +X(scan_in_i37) +X(scan_in_i4) +X(scan_in_i5) +X(scan_in_i6) +X(scan_in_i7) +X(scan_in_i8) +X(scan_in_i9) +X(scan_out_o1) +X(scan_out_o10) +X(scan_out_o11) +X(scan_out_o12) +X(scan_out_o13) +X(scan_out_o14) +X(scan_out_o15) +X(scan_out_o16) +X(scan_out_o17) +X(scan_out_o18) +X(scan_out_o19) +X(scan_out_o2) +X(scan_out_o20) +X(scan_out_o21) +X(scan_out_o22) +X(scan_out_o23) +X(scan_out_o24) +X(scan_out_o25) +X(scan_out_o26) +X(scan_out_o27) +X(scan_out_o28) +X(scan_out_o29) +X(scan_out_o3) +X(scan_out_o30) +X(scan_out_o31) +X(scan_out_o32) +X(scan_out_o33) +X(scan_out_o34) +X(scan_out_o35) +X(scan_out_o36) +X(scan_out_o37) +X(scan_out_o4) +X(scan_out_o5) +X(scan_out_o6) +X(scan_out_o7) +X(scan_out_o8) +X(scan_out_o9) + +// PMA +X(PMA) +X(CAL_OUT_O) +//X(CLK_O) +X(CLK_RX_O) +X(DBG_A_I) +X(DBG_R_O) +//X(DBG_S_I1) +//X(DBG_S_I2) +X(DC_ADD_I1) +X(DC_ADD_I2) +X(DC_ADD_I3) +X(DC_ADD_I4) +X(DC_CCSN_I) +X(DC_E_I) +X(DC_LCSN_I1) +X(DC_LCSN_I2) +X(DC_LCSN_I3) +X(DC_LCSN_I4) +X(DC_WDATAS_I) +X(DC_WDATA_I1) +X(DC_WDATA_I10) +X(DC_WDATA_I11) +X(DC_WDATA_I12) +X(DC_WDATA_I2) +X(DC_WDATA_I3) +X(DC_WDATA_I4) +X(DC_WDATA_I5) +X(DC_WDATA_I6) +X(DC_WDATA_I7) +X(DC_WDATA_I8) +X(DC_WDATA_I9) +X(DC_WE_N_I) +X(FB_LOCK_O) +X(LINK_RX0) +X(LINK_RX1) +X(LINK_RX2) +X(LINK_RX3) +X(LINK_TX0) +X(LINK_TX1) +X(LINK_TX2) +X(LINK_TX3) +X(LL_O1) +X(LL_O10) +X(LL_O11) +X(LL_O12) +X(LL_O13) +X(LL_O14) +X(LL_O15) +X(LL_O16) +X(LL_O17) +X(LL_O18) +X(LL_O19) +X(LL_O2) +X(LL_O20) +X(LL_O3) +X(LL_O4) +X(LL_O5) +X(LL_O6) +X(LL_O7) +X(LL_O8) +X(LL_O9) +X(LOCKA_O) +X(LOCK_O) +X(PLL_RN_I) +//X(PWDN_N_I) +//X(RST_N_I) +X(SCAN_I1) +X(SCAN_I2) +X(SCAN_I3) +X(SCAN_I4) +X(SCAN_I5) +X(SCAN_I6) +X(SCAN_I7) +X(SCAN_I8) +X(SCAN_O1) +X(SCAN_O2) +X(SCAN_O3) +X(SCAN_O4) +X(SCAN_O5) +X(SCAN_O6) +X(SCAN_O7) +X(SCAN_O8) +X(SE_I) +X(calibrate) +X(ckrefn) +X(ckrefp) +X(hssl_clock_i1) +X(hssl_clock_i2) +X(hssl_clock_i3) +X(hssl_clock_i4) +X(pll_ckref_in) +X(pll_ckref_out) +X(pma_pll_fbr_clk_ref_o) +X(rx0n) +X(rx0p) +X(rx1n) +X(rx1p) +X(rx2n) +X(rx2p) +X(rx3n) +X(rx3p) +X(tx0n) +X(tx0p) +X(tx1n) +X(tx1p) +X(tx2n) +X(tx2p) +X(tx3n) +X(tx3p) + +// RAM +X(RAM) +X(AA1) +X(AA10) +X(AA11) +X(AA12) +X(AA13) +X(AA14) +X(AA15) +X(AA16) +X(AA2) +X(AA3) +X(AA4) +X(AA5) +X(AA6) +X(AA7) +X(AA8) +X(AA9) +X(ACK) +X(ACKC) +X(ACKD) +X(ACKR) +X(ACOR) +X(ACS) +X(AERR) +//X(AI1) +X(AI10) +X(AI11) +X(AI12) +X(AI13) +X(AI14) +X(AI15) +X(AI16) +X(AI17) +X(AI18) +X(AI19) +//X(AI2) +X(AI20) +X(AI21) +X(AI22) +X(AI23) +X(AI24) +//X(AI3) +//X(AI4) +//X(AI5) +//X(AI6) +X(AI7) +X(AI8) +X(AI9) +//X(AO1) +X(AO10) +X(AO11) +X(AO12) +X(AO13) +X(AO14) +X(AO15) +X(AO16) +X(AO17) +X(AO18) +X(AO19) +//X(AO2) +X(AO20) +X(AO21) +X(AO22) +X(AO23) +X(AO24) +//X(AO3) +//X(AO4) +//X(AO5) +//X(AO6) +X(AO7) +X(AO8) +X(AO9) +X(AR) +X(AWE) +X(BA1) +X(BA10) +X(BA11) +X(BA12) +X(BA13) +X(BA14) +X(BA15) +X(BA16) +X(BA2) +X(BA3) +X(BA4) +X(BA5) +X(BA6) +X(BA7) +X(BA8) +X(BA9) +X(BCK) +X(BCKC) +X(BCKD) +X(BCKR) +X(BCOR) +X(BCS) +X(BERR) +//X(BI1) +X(BI10) +X(BI11) +X(BI12) +X(BI13) +X(BI14) +X(BI15) +X(BI16) +X(BI17) +X(BI18) +X(BI19) +//X(BI2) +X(BI20) +X(BI21) +X(BI22) +X(BI23) +X(BI24) +//X(BI3) +//X(BI4) +//X(BI5) +//X(BI6) +X(BI7) +X(BI8) +X(BI9) +//X(BO1) +X(BO10) +X(BO11) +X(BO12) +X(BO13) +X(BO14) +X(BO15) +X(BO16) +X(BO17) +X(BO18) +X(BO19) +//X(BO2) +X(BO20) +X(BO21) +X(BO22) +X(BO23) +X(BO24) +//X(BO3) +//X(BO4) +//X(BO5) +//X(BO6) +X(BO7) +X(BO8) +X(BO9) +X(BR) +X(BWE) + +// RF +X(RF) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +X(RA1) +X(RA2) +X(RA3) +X(RA4) +X(RA5) +X(WA1) +X(WA2) +X(WA3) +X(WA4) +X(WA5) +//X(WCK) +//X(WE) +//X(WEA) + +// RFSP +X(RFSP) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RA1) +//X(RA2) +//X(RA3) +//X(RA4) +//X(RA5) +//X(WA1) +//X(WA2) +//X(WA3) +//X(WA4) +//X(WA5) +//X(WCK) +//X(WE) +//X(WEA) + +// SCC +X(SCC) +//X(C) +//X(I) +//X(J) +//X(K) +//X(O) +//X(P) +//X(S) + +// SCI +X(SCI) +//X(I) +//X(O) + +// SCO +X(SCO) +//X(I) +//X(O) + +// SEA +X(SEA) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// SEB +X(SEB) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// SIC +X(SIC) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(O1) +//X(O2) +//X(O3) +//X(O4) + +// SLT +X(SLT) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// SSA +X(SSA) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(O1) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) + +// SSB +X(SSB) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(O1) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) + +// SSI +X(SSI) +//X(I) +//X(O) + +// TCI +X(TCI) +//X(I) +//X(O) + +// TCO +X(TCO) +//X(I) +//X(O) + +// TDE +X(TDE) +//X(ADRSTI) +//X(ADRSTO) +//X(AI1) +//X(AI2) +//X(AI3) +//X(AI4) +//X(AI5) +//X(AI6) +//X(AO1) +//X(AO2) +//X(AO3) +//X(AO4) +//X(AO5) +//X(AO6) +//X(ASRSTI) +//X(ASRSTO) +//X(BDRSTI) +//X(BDRSTO) +//X(BI1) +//X(BI2) +//X(BI3) +//X(BI4) +//X(BI5) +//X(BI6) +//X(BO1) +//X(BO2) +//X(BO3) +//X(BO4) +//X(BO5) +//X(BO6) +//X(BSRSTI) +//X(BSRSTO) +//X(CK1) +//X(CK2) + +// TEA +X(TEA) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// TEB +X(TEB) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// TIA +X(TIA) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// TIB +X(TIB) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) + +// TLT +X(TLT) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O33) +//X(O34) +//X(O35) +//X(O36) +//X(O37) +//X(O38) +//X(O39) +//X(O4) +//X(O40) +//X(O41) +//X(O42) +//X(O43) +//X(O44) +//X(O45) +//X(O46) +//X(O47) +//X(O48) +X(O49) +//X(O5) +X(O50) +X(O51) +X(O52) +X(O53) +X(O54) +X(O55) +X(O56) +X(O57) +X(O58) +X(O59) +//X(O6) +X(O60) +X(O61) +X(O62) +X(O63) +X(O64) +X(O65) +X(O66) +X(O67) +X(O68) +X(O69) +//X(O7) +X(O70) +X(O71) +X(O72) +X(O73) +X(O74) +X(O75) +X(O76) +X(O77) +X(O78) +X(O79) +//X(O8) +X(O80) +X(O81) +X(O82) +X(O83) +X(O84) +X(O85) +X(O86) +//X(O9) + +// TSA +X(TSA) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) + +// TSB +X(TSB) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(O1) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) + +// TSI +X(TSI) +//X(I) +//X(O) + +// TSO +X(TSO) +//X(I) +//X(O) + +// TSS +X(TSS) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I33) +//X(I34) +//X(I35) +//X(I36) +//X(I37) +//X(I38) +//X(I39) +//X(I4) +//X(I40) +//X(I41) +//X(I42) +//X(I43) +//X(I44) +//X(I45) +//X(I46) +//X(I47) +//X(I48) +X(I49) +//X(I5) +X(I50) +X(I51) +X(I52) +X(I53) +X(I54) +X(I55) +X(I56) +X(I57) +X(I58) +X(I59) +//X(I6) +X(I60) +X(I61) +X(I62) +X(I63) +X(I64) +X(I65) +X(I66) +X(I67) +X(I68) +X(I69) +//X(I7) +X(I70) +X(I71) +X(I72) +X(I73) +X(I74) +X(I75) +X(I76) +//X(I8) +//X(I9) +//X(O1) +//X(O2) +//X(O3) +//X(O4) + +// WFB +X(WFB) +X(ZI) +X(ZO) + +// WFG +X(WFG) +//X(R) +X(SI) +//X(SO) +//X(ZI) +//X(ZO) + +// XCDC +X(XCDC) +//X(ADRSTI) +//X(ADRSTO) +//X(AI1) +//X(AI2) +//X(AI3) +//X(AI4) +//X(AI5) +//X(AI6) +//X(AO1) +//X(AO2) +//X(AO3) +//X(AO4) +//X(AO5) +//X(AO6) +//X(ASRSTI) +//X(ASRSTO) +//X(BDRSTI) +//X(BDRSTO) +//X(BI1) +//X(BI2) +//X(BI3) +//X(BI4) +//X(BI5) +//X(BI6) +//X(BO1) +//X(BO2) +//X(BO3) +//X(BO4) +//X(BO5) +//X(BO6) +//X(BSRSTI) +//X(BSRSTO) +X(CDRSTI) +X(CDRSTO) +X(CI1) +X(CI2) +X(CI3) +X(CI4) +X(CI5) +X(CI6) +//X(CK1) +//X(CK2) +X(CO1) +X(CO2) +X(CO3) +X(CO4) +X(CO5) +X(CO6) +X(CSRSTI) +X(CSRSTO) +X(DDRSTI) +X(DDRSTO) +X(DI1) +X(DI2) +X(DI3) +X(DI4) +X(DI5) +X(DI6) +X(DO1) +X(DO2) +X(DO3) +X(DO4) +X(DO5) +X(DO6) +X(DSRSTI) +X(DSRSTO) + +// XFIFO +X(XFIFO) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I33) +//X(I34) +//X(I35) +//X(I36) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O33) +//X(O34) +//X(O35) +//X(O36) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RAI1) +//X(RAI2) +//X(RAI3) +//X(RAI4) +//X(RAI5) +//X(RAI6) +X(RAI7) +//X(RAO1) +//X(RAO2) +//X(RAO3) +//X(RAO4) +//X(RAO5) +//X(RAO6) +X(RAO7) +X(RCK1) +X(RCK2) +X(REQ1) +X(REQ2) +//X(RRSTI1) +//X(RRSTI2) +X(RRSTI3) +X(RRSTI4) +//X(RRSTO) +//X(WAI1) +//X(WAI2) +//X(WAI3) +//X(WAI4) +//X(WAI5) +//X(WAI6) +X(WAI7) +//X(WAO1) +//X(WAO2) +//X(WAO3) +//X(WAO4) +//X(WAO5) +//X(WAO6) +X(WAO7) +X(WCK1) +X(WCK2) +//X(WE) +//X(WEA) +X(WEQ1) +X(WEQ2) +//X(WRSTI1) +//X(WRSTI2) +X(WRSTI3) +X(WRSTI4) +//X(WRSTO) + +// XHFIFO +X(XHFIFO) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RAI1) +//X(RAI2) +//X(RAI3) +//X(RAI4) +//X(RAI5) +//X(RAI6) +//X(RAI7) +//X(RAO1) +//X(RAO2) +//X(RAO3) +//X(RAO4) +//X(RAO5) +//X(RAO6) +//X(RAO7) +//X(RCK1) +//X(RCK2) +//X(REQ1) +//X(REQ2) +//X(RRSTI1) +//X(RRSTI2) +//X(RRSTI3) +//X(RRSTI4) +//X(WAI1) +//X(WAI2) +//X(WAI3) +//X(WAI4) +//X(WAI5) +//X(WAI6) +//X(WAI7) +//X(WAO1) +//X(WAO2) +//X(WAO3) +//X(WAO4) +//X(WAO5) +//X(WAO6) +//X(WAO7) +//X(WCK1) +//X(WCK2) +//X(WE) +//X(WEA) +//X(WEQ1) +//X(WEQ2) +//X(WRSTI1) +//X(WRSTI2) +//X(WRSTI3) +//X(WRSTI4) + +// XHRF +X(XHRF) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O2) +//X(O3) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RA1) +//X(RA2) +//X(RA3) +//X(RA4) +//X(RA5) +X(RA6) +//X(WA1) +//X(WA2) +//X(WA3) +//X(WA4) +//X(WA5) +X(WA6) +//X(WCK1) +//X(WCK2) +//X(WE) +//X(WEA) + +// XLUT +X(XLUT) +X(G1) +X(G2) +X(G3) +X(G4) +//X(I1) +//X(I2) +//X(I3) +//X(I4) +//X(J) +//X(O) + +// XPRF +X(XPRF) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I2) +//X(I3) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O33) +//X(O34) +//X(O35) +//X(O36) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RA1) +X(RA10) +//X(RA2) +//X(RA3) +//X(RA4) +//X(RA5) +//X(RA6) +X(RA7) +X(RA8) +X(RA9) +//X(WA1) +//X(WA2) +//X(WA3) +//X(WA4) +//X(WA5) +//X(WCK1) +//X(WCK2) +//X(WE) +//X(WEA) + +// XRF +X(XRF) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I33) +//X(I34) +//X(I35) +//X(I36) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O33) +//X(O34) +//X(O35) +//X(O36) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RA1) +//X(RA10) +//X(RA2) +//X(RA3) +//X(RA4) +//X(RA5) +//X(RA6) +//X(RA7) +//X(RA8) +//X(RA9) +//X(WA1) +//X(WA2) +//X(WA3) +//X(WA4) +//X(WA5) +//X(WA6) +//X(WCK1) +//X(WCK2) +//X(WE) +//X(WEA) + +// XWFIFO +X(XWFIFO) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I33) +//X(I34) +//X(I35) +//X(I36) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O33) +//X(O34) +//X(O35) +//X(O36) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RAI1) +//X(RAI2) +//X(RAI3) +//X(RAI4) +//X(RAI5) +//X(RAI6) +//X(RAO1) +//X(RAO2) +//X(RAO3) +//X(RAO4) +//X(RAO5) +//X(RAO6) +//X(RCK1) +//X(RCK2) +//X(REQ) +//X(RRSTI1) +//X(RRSTI2) +//X(WAI1) +//X(WAI2) +//X(WAI3) +//X(WAI4) +//X(WAI5) +//X(WAI6) +//X(WAO1) +//X(WAO2) +//X(WAO3) +//X(WAO4) +//X(WAO5) +//X(WAO6) +//X(WCK1) +//X(WCK2) +//X(WE) +//X(WEA) +//X(WEQ) +//X(WRSTI1) +//X(WRSTI2) + +// XWRF +X(XWRF) +//X(I1) +//X(I10) +//X(I11) +//X(I12) +//X(I13) +//X(I14) +//X(I15) +//X(I16) +//X(I17) +//X(I18) +//X(I19) +//X(I2) +//X(I20) +//X(I21) +//X(I22) +//X(I23) +//X(I24) +//X(I25) +//X(I26) +//X(I27) +//X(I28) +//X(I29) +//X(I3) +//X(I30) +//X(I31) +//X(I32) +//X(I33) +//X(I34) +//X(I35) +//X(I36) +//X(I4) +//X(I5) +//X(I6) +//X(I7) +//X(I8) +//X(I9) +//X(O1) +//X(O10) +//X(O11) +//X(O12) +//X(O13) +//X(O14) +//X(O15) +//X(O16) +//X(O17) +//X(O18) +//X(O19) +//X(O2) +//X(O20) +//X(O21) +//X(O22) +//X(O23) +//X(O24) +//X(O25) +//X(O26) +//X(O27) +//X(O28) +//X(O29) +//X(O3) +//X(O30) +//X(O31) +//X(O32) +//X(O33) +//X(O34) +//X(O35) +//X(O36) +//X(O4) +//X(O5) +//X(O6) +//X(O7) +//X(O8) +//X(O9) +//X(RA1) +//X(RA2) +//X(RA3) +//X(RA4) +//X(RA5) +//X(WA1) +//X(WA2) +//X(WA3) +//X(WA4) +//X(WA5) +//X(WCK1) +//X(WCK2) +//X(WE) +//X(WEA) + +// end of autogenerated items + +// start of generated parameter list +// NX_BD +X(NX_BD) +X(mode) + +// NX_BFF +X(NX_BFF) + +// NX_BFR +X(NX_BFR) +X(data_inv) +X(iobname) +X(location) +//X(mode) +X(path) +X(ring) + +// NX_CDC_L +X(NX_CDC_L) +X(ack_sel) +X(bck_sel) +X(cck_sel) +X(ck0_edge) +X(ck1_edge) +X(dck_sel) +X(gt0_bypass_reg1) +X(gt0_bypass_reg2) +X(gt1_bypass_reg1) +X(gt1_bypass_reg2) +X(link_BA) +X(link_CB) +X(link_DC) +//X(mode) +X(use_adest_arst) +X(use_asrc_arst) +X(use_bdest_arst) +X(use_bsrc_arst) +X(use_cdest_arst) +X(use_csrc_arst) +X(use_ddest_arst) +X(use_dsrc_arst) + +// NX_CDC_L_2DFF +X(NX_CDC_L_2DFF) +//X(ack_sel) +//X(bck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(gt0_bypass_reg1) +//X(gt0_bypass_reg2) +//X(gt1_bypass_reg1) +//X(gt1_bypass_reg2) +//X(use_adest_arst) +//X(use_bdest_arst) + +// NX_CDC_L_3DFF +X(NX_CDC_L_3DFF) +//X(ack_sel) +//X(bck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(gt0_bypass_reg1) +//X(gt0_bypass_reg2) +//X(gt1_bypass_reg1) +//X(gt1_bypass_reg2) +//X(use_adest_arst) +//X(use_asrc_arst) +//X(use_bdest_arst) +//X(use_bsrc_arst) + +// NX_CDC_L_BIN2GRAY +X(NX_CDC_L_BIN2GRAY) + +// NX_CDC_L_FULL +X(NX_CDC_L_FULL) +//X(ack_sel) +//X(bck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(gt0_bypass_reg1) +//X(gt0_bypass_reg2) +//X(gt1_bypass_reg1) +//X(gt1_bypass_reg2) +//X(use_adest_arst) +//X(use_asrc_arst) +//X(use_bdest_arst) +//X(use_bsrc_arst) + +// NX_CDC_U +X(NX_CDC_U) +//X(ack_sel) +//X(bck_sel) +//X(cck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(dck_sel) +//X(link_BA) +//X(link_CB) +//X(link_DC) +//X(mode) +//X(use_adest_arst) +//X(use_asrc_arst) +//X(use_bdest_arst) +//X(use_bsrc_arst) +//X(use_cdest_arst) +//X(use_csrc_arst) +//X(use_ddest_arst) +//X(use_dsrc_arst) + +// NX_CDC_U_2DFF +X(NX_CDC_U_2DFF) +//X(ack_sel) +//X(bck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(use_adest_arst) +//X(use_bdest_arst) + +// NX_CDC_U_3DFF +X(NX_CDC_U_3DFF) +//X(ack_sel) +//X(bck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(use_adest_arst) +//X(use_asrc_arst) +//X(use_bdest_arst) +//X(use_bsrc_arst) + +// NX_CDC_U_BIN2GRAY +X(NX_CDC_U_BIN2GRAY) + +// NX_CDC_U_FULL +X(NX_CDC_U_FULL) +//X(ack_sel) +//X(bck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(use_adest_arst) +//X(use_asrc_arst) +//X(use_bdest_arst) +//X(use_bsrc_arst) + +// NX_CDC_U_GRAY2BIN +X(NX_CDC_U_GRAY2BIN) + +// NX_CKS +X(NX_CKS) +X(ck_edge) + +// NX_CKS_U +X(NX_CKS_U) + +// NX_CMUX_U +X(NX_CMUX_U) + +// NX_CRX_L +X(NX_CRX_L) +//X(location) +X(pcs_8b_dscr_sel) +X(pcs_align_bypass) +X(pcs_buffers_bypass) +X(pcs_buffers_use_cdc) +X(pcs_bypass_pma_cdc) +X(pcs_bypass_usr_cdc) +X(pcs_comma_mask) +X(pcs_debug_en) +X(pcs_dec_bypass) +X(pcs_dscr_bypass) +X(pcs_el_buff_diff_bef_comp) +X(pcs_el_buff_max_comp) +X(pcs_el_buff_only_one_skp) +X(pcs_el_buff_skp_char_0) +X(pcs_el_buff_skp_char_1) +X(pcs_el_buff_skp_char_2) +X(pcs_el_buff_skp_char_3) +X(pcs_el_buff_skp_header_0) +X(pcs_el_buff_skp_header_1) +X(pcs_el_buff_skp_header_2) +X(pcs_el_buff_skp_header_3) +X(pcs_el_buff_skp_header_size) +X(pcs_el_buff_skp_seq_size) +X(pcs_el_buff_underflow_handle) +X(pcs_fsm_sel) +X(pcs_fsm_watchdog_en) +X(pcs_loopback) +X(pcs_m_comma_en) +X(pcs_m_comma_val) +X(pcs_nb_comma_bef_realign) +X(pcs_p_comma_en) +X(pcs_p_comma_val) +X(pcs_polarity) +X(pcs_protocol_size) +X(pcs_replace_bypass) +X(pcs_sync_supported) +X(pma_cdr_cp) +X(pma_clk_pos) +X(pma_ctrl_term) +X(pma_loopback) +X(pma_pll_cpump_n) +X(pma_pll_divf) +X(pma_pll_divf_en_n) +X(pma_pll_divm) +X(pma_pll_divm_en_n) +X(pma_pll_divn) +X(pma_pll_divn_en_n) +X(test) + +// NX_CRX_U +X(NX_CRX_U) +X(gearbox_en) +X(gearbox_mode) +//X(location) +//X(pcs_8b_dscr_sel) +//X(pcs_align_bypass) +//X(pcs_buffers_bypass) +//X(pcs_buffers_use_cdc) +//X(pcs_bypass_pma_cdc) +//X(pcs_bypass_usr_cdc) +//X(pcs_comma_mask) +//X(pcs_debug_en) +//X(pcs_dec_bypass) +//X(pcs_dscr_bypass) +//X(pcs_el_buff_diff_bef_comp) +//X(pcs_el_buff_max_comp) +//X(pcs_el_buff_only_one_skp) +//X(pcs_el_buff_skp_char_0) +//X(pcs_el_buff_skp_char_1) +//X(pcs_el_buff_skp_char_2) +//X(pcs_el_buff_skp_char_3) +//X(pcs_el_buff_skp_header_0) +//X(pcs_el_buff_skp_header_1) +//X(pcs_el_buff_skp_header_2) +//X(pcs_el_buff_skp_header_3) +//X(pcs_el_buff_skp_header_size) +//X(pcs_el_buff_skp_seq_size) +//X(pcs_fsm_sel) +//X(pcs_fsm_watchdog_en) +//X(pcs_loopback) +//X(pcs_m_comma_en) +//X(pcs_m_comma_val) +//X(pcs_nb_comma_bef_realign) +//X(pcs_p_comma_en) +//X(pcs_p_comma_val) +//X(pcs_polarity) +//X(pcs_protocol_size) +//X(pcs_replace_bypass) +//X(pcs_sync_supported) +//X(pma_cdr_cp) +//X(pma_clk_pos) +X(pma_coarse_ppm) +//X(pma_ctrl_term) +X(pma_dco_divl) +X(pma_dco_divm) +X(pma_dco_divn) +X(pma_dco_reg_res) +X(pma_dco_vref_sel) +X(pma_fine_ppm) +//X(pma_loopback) +X(pma_m_eye_ppm) +X(pma_peak_detect_cmd) +X(pma_peak_detect_on) +//X(pma_pll_cpump_n) +//X(pma_pll_divf) +//X(pma_pll_divf_en_n) +//X(pma_pll_divm) +//X(pma_pll_divm_en_n) +//X(pma_pll_divn) +//X(pma_pll_divn_en_n) + +// NX_CTX_L +X(NX_CTX_L) +//X(location) +X(pcs_8b_scr_sel) +//X(pcs_bypass_pma_cdc) +//X(pcs_bypass_usr_cdc) +X(pcs_enc_bypass) +X(pcs_esistream_fsm_en) +//X(pcs_loopback) +//X(pcs_polarity) +//X(pcs_protocol_size) +//X(pcs_replace_bypass) +X(pcs_scr_bypass) +X(pcs_scr_init) +//X(pcs_sync_supported) +//X(pma_clk_pos) +//X(pma_loopback) +//X(test) + +// NX_CTX_U +X(NX_CTX_U) +//X(gearbox_en) +//X(gearbox_mode) +//X(location) +//X(pcs_8b_scr_sel) +//X(pcs_bypass_pma_cdc) +//X(pcs_bypass_usr_cdc) +//X(pcs_enc_bypass) +//X(pcs_esistream_fsm_en) +//X(pcs_loopback) +//X(pcs_polarity) +//X(pcs_protocol_size) +//X(pcs_replace_bypass) +//X(pcs_scr_bypass) +//X(pcs_scr_init) +//X(pcs_sync_supported) +//X(pma_clk_pos) +//X(pma_loopback) + +// NX_CY +X(NX_CY) +X(add_carry) + +// NX_DES +X(NX_DES) +X(data_size) +X(differential) +X(dpath_dynamic) +X(drive) +X(inputDelayLine) +X(inputSignalSlope) +//X(location) +X(locked) +X(standard) +X(termination) +X(terminationReference) +X(turbo) +X(weakTermination) + +// NX_DFF +X(NX_DFF) +X(dff_ctxt) +X(dff_edge) +X(dff_init) +X(dff_load) +X(dff_sync) +X(dff_type) + +// NX_DFR +X(NX_DFR) +//X(data_inv) +//X(dff_edge) +//X(dff_init) +//X(dff_load) +//X(dff_sync) +//X(dff_type) +//X(iobname) +//X(location) +//X(mode) +//X(path) +//X(ring) + +// NX_DSP +X(NX_DSP) +X(raw_config0) +X(raw_config1) +X(raw_config2) +X(raw_config3) +X(std_mode) + +// NX_DSP_L +X(NX_DSP_L) +//X(raw_config0) +//X(raw_config1) +//X(raw_config2) +//X(raw_config3) +//X(std_mode) + +// NX_DSP_L_SPLIT +X(NX_DSP_L_SPLIT) +X(ALU_DYNAMIC_OP) +X(ALU_MUX) +X(ALU_OP) +X(CO_SEL) +X(ENABLE_PR_ALU_RST) +X(ENABLE_PR_A_RST) +X(ENABLE_PR_B_RST) +X(ENABLE_PR_CI_RST) +X(ENABLE_PR_CO_RST) +X(ENABLE_PR_C_RST) +X(ENABLE_PR_D_RST) +X(ENABLE_PR_MULT_RST) +X(ENABLE_PR_OV_RST) +X(ENABLE_PR_P_RST) +X(ENABLE_PR_X_RST) +X(ENABLE_PR_Y_RST) +X(ENABLE_PR_Z_RST) +X(ENABLE_SATURATION) +X(MUX_A) +X(MUX_B) +X(MUX_CI) +X(MUX_P) +X(MUX_X) +X(MUX_Y) +X(MUX_Z) +X(PRE_ADDER_OP) +X(PR_ALU_MUX) +X(PR_A_CASCADE_MUX) +X(PR_A_MUX) +X(PR_B_CASCADE_MUX) +X(PR_B_MUX) +X(PR_CI_MUX) +X(PR_CO_MUX) +X(PR_C_MUX) +X(PR_D_MUX) +X(PR_MULT_MUX) +X(PR_OV_MUX) +X(PR_P_MUX) +X(PR_X_MUX) +X(PR_Y_MUX) +X(PR_Z_MUX) +X(SATURATION_RANK) +X(SIGNED_MODE) +X(Z_FEEDBACK_SHL12) + +// NX_DSP_L_WRAP +X(NX_DSP_L_WRAP) +//X(raw_config0) +//X(raw_config1) +//X(raw_config2) +//X(raw_config3) +//X(std_mode) + +// NX_DSP_SPLIT +X(NX_DSP_SPLIT) +//X(ALU_DYNAMIC_OP) +//X(ALU_MUX) +//X(ALU_OP) +//X(CO_SEL) +//X(ENABLE_PR_ALU_RST) +//X(ENABLE_PR_A_RST) +//X(ENABLE_PR_B_RST) +//X(ENABLE_PR_CI_RST) +//X(ENABLE_PR_CO_RST) +//X(ENABLE_PR_C_RST) +//X(ENABLE_PR_D_RST) +//X(ENABLE_PR_MULT_RST) +//X(ENABLE_PR_OV_RST) +//X(ENABLE_PR_P_RST) +//X(ENABLE_PR_X_RST) +//X(ENABLE_PR_Y_RST) +//X(ENABLE_PR_Z_RST) +//X(ENABLE_SATURATION) +//X(MUX_A) +//X(MUX_B) +//X(MUX_CI) +//X(MUX_P) +//X(MUX_X) +//X(MUX_Y) +//X(MUX_Z) +//X(PRE_ADDER_OP) +//X(PR_ALU_MUX) +//X(PR_A_CASCADE_MUX) +//X(PR_A_MUX) +//X(PR_B_CASCADE_MUX) +//X(PR_B_MUX) +//X(PR_CI_MUX) +//X(PR_CO_MUX) +//X(PR_C_MUX) +//X(PR_D_MUX) +//X(PR_MULT_MUX) +//X(PR_OV_MUX) +//X(PR_P_MUX) +//X(PR_X_MUX) +//X(PR_Y_MUX) +//X(PR_Z_MUX) +//X(SATURATION_RANK) +//X(SIGNED_MODE) +//X(Z_FEEDBACK_SHL12) + +// NX_DSP_U +X(NX_DSP_U) +//X(raw_config0) +//X(raw_config1) +//X(raw_config2) +//X(raw_config3) +//X(std_mode) + +// NX_DSP_U_SPLIT +X(NX_DSP_U_SPLIT) +//X(ALU_DYNAMIC_OP) +//X(ALU_OP) +//X(ENABLE_PR_A_RST) +//X(ENABLE_PR_B_RST) +X(ENABLE_PR_CCO_RST) +//X(ENABLE_PR_CI_RST) +//X(ENABLE_PR_CO_RST) +X(ENABLE_PR_CZ_RST) +//X(ENABLE_PR_C_RST) +//X(ENABLE_PR_D_RST) +//X(ENABLE_PR_MULT_RST) +//X(ENABLE_PR_OV_RST) +//X(ENABLE_PR_P_RST) +//X(ENABLE_PR_X_RST) +//X(ENABLE_PR_Y_RST) +//X(ENABLE_PR_Z_RST) +//X(ENABLE_SATURATION) +X(INV_RST) +X(INV_RSTZ) +X(INV_WE) +X(INV_WEZ) +//X(MUX_A) +//X(MUX_B) +X(MUX_CCI) +X(MUX_CCO) +//X(MUX_CI) +X(MUX_CZ) +//X(MUX_P) +//X(MUX_X) +//X(MUX_Y) +//X(MUX_Z) +//X(PRE_ADDER_OP) +//X(PR_A_CASCADE_MUX) +//X(PR_A_MUX) +//X(PR_B_CASCADE_MUX) +//X(PR_B_MUX) +X(PR_CCO_MUX) +//X(PR_CI_MUX) +//X(PR_CO_MUX) +X(PR_CZ_MUX) +//X(PR_C_MUX) +//X(PR_D_MUX) +//X(PR_MULT_MUX) +//X(PR_OV_MUX) +//X(PR_P_MUX) +X(PR_RSTZ_MUX) +X(PR_RST_MUX) +X(PR_WEZ_MUX) +X(PR_WE_MUX) +//X(PR_X_MUX) +//X(PR_Y_MUX) +//X(PR_Z_MUX) +//X(SATURATION_RANK) +//X(SIGNED_MODE) + +// NX_DSP_U_WRAP +X(NX_DSP_U_WRAP) +//X(raw_config0) +//X(raw_config1) +//X(raw_config2) +//X(raw_config3) +//X(std_mode) + +// NX_DSP_WRAP +X(NX_DSP_WRAP) +//X(raw_config0) +//X(raw_config1) +//X(raw_config2) +//X(raw_config3) +//X(std_mode) + +// NX_ECC +X(NX_ECC) + +// NX_FIFO_DPREG +X(NX_FIFO_DPREG) +X(rck_edge) +X(read_addr_inv) +X(use_read_arst) +X(use_write_arst) +X(wck_edge) + +// NX_FIFO_U +X(NX_FIFO_U) +//X(mode) +//X(rck_edge) +//X(read_addr_inv) +//X(use_read_arst) +//X(use_write_arst) +//X(wck_edge) + +// NX_GCK_U +X(NX_GCK_U) +X(inv_in) +X(inv_out) +//X(std_mode) + +// NX_HSSL_L_FULL +X(NX_HSSL_L_FULL) +X(cfg_main_i) +X(cfg_rx0_i) +X(cfg_rx1_i) +X(cfg_rx2_i) +X(cfg_rx3_i) +X(cfg_rx4_i) +X(cfg_rx5_i) +X(cfg_tx0_i) +X(cfg_tx1_i) +X(cfg_tx2_i) +X(cfg_tx3_i) +X(cfg_tx4_i) +X(cfg_tx5_i) +//X(location) + +// NX_HSSL_U_FULL +X(NX_HSSL_U_FULL) +X(cfg_dyn_all_rx_pma_m_eye_coarse_ena_i) +X(cfg_dyn_all_rx_pma_m_eye_dn_i) +X(cfg_dyn_all_rx_pma_m_eye_fine_ena_i) +X(cfg_dyn_all_rx_pma_m_eye_i) +X(cfg_dyn_all_rx_pma_m_eye_step_i) +X(cfg_dyn_all_rx_pma_m_eye_up_i) +X(cfg_dyn_all_rx_pma_threshold_1) +X(cfg_dyn_all_rx_pma_threshold_2) +X(cfg_dyn_all_rx_pma_trim_locked_i) +X(cfg_dyn_all_rx_pma_trim_mode_i) +X(cfg_dyn_all_rx_pma_trim_unlocked_i) +X(cfg_dyn_rx0_pma_ctle_cap_p_i) +X(cfg_dyn_rx0_pma_ctle_res_p_i) +X(cfg_dyn_rx0_pma_dfe_idac_tap1_n_i) +X(cfg_dyn_rx0_pma_dfe_idac_tap2_n_i) +X(cfg_dyn_rx0_pma_dfe_idac_tap3_n_i) +X(cfg_dyn_rx0_pma_dfe_idac_tap4_n_i) +X(cfg_dyn_rx0_pma_termination_cmd_i) +X(cfg_dyn_rx1_pma_ctle_cap_p_i) +X(cfg_dyn_rx1_pma_ctle_res_p_i) +X(cfg_dyn_rx1_pma_dfe_idac_tap1_n_i) +X(cfg_dyn_rx1_pma_dfe_idac_tap2_n_i) +X(cfg_dyn_rx1_pma_dfe_idac_tap3_n_i) +X(cfg_dyn_rx1_pma_dfe_idac_tap4_n_i) +X(cfg_dyn_rx1_pma_termination_cmd_i) +X(cfg_dyn_rx2_pma_ctle_cap_p_i) +X(cfg_dyn_rx2_pma_ctle_res_p_i) +X(cfg_dyn_rx2_pma_dfe_idac_tap1_n_i) +X(cfg_dyn_rx2_pma_dfe_idac_tap2_n_i) +X(cfg_dyn_rx2_pma_dfe_idac_tap3_n_i) +X(cfg_dyn_rx2_pma_dfe_idac_tap4_n_i) +X(cfg_dyn_rx2_pma_termination_cmd_i) +X(cfg_dyn_rx3_pma_ctle_cap_p_i) +X(cfg_dyn_rx3_pma_ctle_res_p_i) +X(cfg_dyn_rx3_pma_dfe_idac_tap1_n_i) +X(cfg_dyn_rx3_pma_dfe_idac_tap2_n_i) +X(cfg_dyn_rx3_pma_dfe_idac_tap3_n_i) +X(cfg_dyn_rx3_pma_dfe_idac_tap4_n_i) +X(cfg_dyn_rx3_pma_termination_cmd_i) +X(cfg_dyn_tx0_pma_main_en_i) +X(cfg_dyn_tx0_pma_main_sign_i) +X(cfg_dyn_tx0_pma_margin_input_i) +X(cfg_dyn_tx0_pma_margin_sel_i) +X(cfg_dyn_tx0_pma_post_en_i) +X(cfg_dyn_tx0_pma_post_sel_i) +X(cfg_dyn_tx0_pma_post_sign_i) +X(cfg_dyn_tx0_pma_pre_en_i) +X(cfg_dyn_tx0_pma_pre_sel_i) +X(cfg_dyn_tx0_pma_pre_sign_i) +X(cfg_dyn_tx1_pma_main_en_i) +X(cfg_dyn_tx1_pma_main_sign_i) +X(cfg_dyn_tx1_pma_margin_input_i) +X(cfg_dyn_tx1_pma_margin_sel_i) +X(cfg_dyn_tx1_pma_post_en_i) +X(cfg_dyn_tx1_pma_post_sel_i) +X(cfg_dyn_tx1_pma_post_sign_i) +X(cfg_dyn_tx1_pma_pre_en_i) +X(cfg_dyn_tx1_pma_pre_sel_i) +X(cfg_dyn_tx1_pma_pre_sign_i) +X(cfg_dyn_tx2_pma_main_en_i) +X(cfg_dyn_tx2_pma_main_sign_i) +X(cfg_dyn_tx2_pma_margin_input_i) +X(cfg_dyn_tx2_pma_margin_sel_i) +X(cfg_dyn_tx2_pma_post_en_i) +X(cfg_dyn_tx2_pma_post_sel_i) +X(cfg_dyn_tx2_pma_post_sign_i) +X(cfg_dyn_tx2_pma_pre_en_i) +X(cfg_dyn_tx2_pma_pre_sel_i) +X(cfg_dyn_tx2_pma_pre_sign_i) +X(cfg_dyn_tx3_pma_main_en_i) +X(cfg_dyn_tx3_pma_main_sign_i) +X(cfg_dyn_tx3_pma_margin_input_i) +X(cfg_dyn_tx3_pma_margin_sel_i) +X(cfg_dyn_tx3_pma_post_en_i) +X(cfg_dyn_tx3_pma_post_sel_i) +X(cfg_dyn_tx3_pma_post_sign_i) +X(cfg_dyn_tx3_pma_pre_en_i) +X(cfg_dyn_tx3_pma_pre_sel_i) +X(cfg_dyn_tx3_pma_pre_sign_i) +X(cfg_main_clk_to_fabric_div_en_i) +X(cfg_main_clk_to_fabric_div_mode_i) +X(cfg_main_clk_to_fabric_sel_i) +X(cfg_main_rclk_to_fabric_sel_i) +X(cfg_main_use_only_usr_clock_i) +X(cfg_pcs_ovs_en_i) +X(cfg_pcs_ovs_mode_i) +X(cfg_pcs_pll_lock_ppm_i) +X(cfg_pcs_word_len_i) +X(cfg_pll_pma_ckref_ext_i) +X(cfg_pll_pma_cpump_i) +X(cfg_pll_pma_divl_i) +X(cfg_pll_pma_divm_i) +X(cfg_pll_pma_divn_i) +X(cfg_pll_pma_gbx_en_i) +X(cfg_pll_pma_int_data_len_i) +X(cfg_pll_pma_lvds_en_i) +X(cfg_pll_pma_lvds_mux_i) +X(cfg_pll_pma_mux_ckref_i) +X(cfg_rx0_gearbox_en_i) +X(cfg_rx0_gearbox_mode_i) +X(cfg_rx0_pcs_8b_dscr_sel_i) +X(cfg_rx0_pcs_align_bypass_i) +X(cfg_rx0_pcs_buffers_bypass_i) +X(cfg_rx0_pcs_buffers_use_cdc_i) +X(cfg_rx0_pcs_bypass_pma_cdc_i) +X(cfg_rx0_pcs_bypass_usr_cdc_i) +X(cfg_rx0_pcs_comma_mask_i) +X(cfg_rx0_pcs_debug_en_i) +X(cfg_rx0_pcs_dec_bypass_i) +X(cfg_rx0_pcs_dscr_bypass_i) +X(cfg_rx0_pcs_el_buff_diff_bef_comp_i) +X(cfg_rx0_pcs_el_buff_max_comp_i) +X(cfg_rx0_pcs_el_buff_only_one_skp_i) +X(cfg_rx0_pcs_el_buff_skp_char_0_i) +X(cfg_rx0_pcs_el_buff_skp_char_1_i) +X(cfg_rx0_pcs_el_buff_skp_char_2_i) +X(cfg_rx0_pcs_el_buff_skp_char_3_i) +X(cfg_rx0_pcs_el_buff_skp_header_0_i) +X(cfg_rx0_pcs_el_buff_skp_header_1_i) +X(cfg_rx0_pcs_el_buff_skp_header_2_i) +X(cfg_rx0_pcs_el_buff_skp_header_3_i) +X(cfg_rx0_pcs_el_buff_skp_header_size_i) +X(cfg_rx0_pcs_el_buff_skp_seq_size_i) +X(cfg_rx0_pcs_fsm_sel_i) +X(cfg_rx0_pcs_fsm_watchdog_en_i) +X(cfg_rx0_pcs_loopback_i) +X(cfg_rx0_pcs_m_comma_en_i) +X(cfg_rx0_pcs_m_comma_val_i) +X(cfg_rx0_pcs_nb_comma_bef_realign_i) +X(cfg_rx0_pcs_p_comma_en_i) +X(cfg_rx0_pcs_p_comma_val_i) +X(cfg_rx0_pcs_polarity_i) +X(cfg_rx0_pcs_protocol_size_i) +X(cfg_rx0_pcs_replace_bypass_i) +X(cfg_rx0_pcs_sync_supported_i) +X(cfg_rx0_pma_cdr_cp_i) +X(cfg_rx0_pma_clk_pos_i) +X(cfg_rx0_pma_coarse_ppm_i) +X(cfg_rx0_pma_ctrl_term_i) +X(cfg_rx0_pma_dco_divl_i) +X(cfg_rx0_pma_dco_divm_i) +X(cfg_rx0_pma_dco_divn_i) +X(cfg_rx0_pma_dco_reg_res_i) +X(cfg_rx0_pma_dco_vref_sel_i) +X(cfg_rx0_pma_fine_ppm_i) +X(cfg_rx0_pma_loopback_i) +X(cfg_rx0_pma_m_eye_ppm_i) +X(cfg_rx0_pma_peak_detect_cmd_i) +X(cfg_rx0_pma_peak_detect_on_i) +X(cfg_rx0_pma_pll_cpump_n_i) +X(cfg_rx0_pma_pll_divf_en_n_i) +X(cfg_rx0_pma_pll_divf_i) +X(cfg_rx0_pma_pll_divm_en_n_i) +X(cfg_rx0_pma_pll_divm_i) +X(cfg_rx0_pma_pll_divn_en_n_i) +X(cfg_rx0_pma_pll_divn_i) +X(cfg_rx1_gearbox_en_i) +X(cfg_rx1_gearbox_mode_i) +X(cfg_rx1_pcs_8b_dscr_sel_i) +X(cfg_rx1_pcs_align_bypass_i) +X(cfg_rx1_pcs_buffers_bypass_i) +X(cfg_rx1_pcs_buffers_use_cdc_i) +X(cfg_rx1_pcs_bypass_pma_cdc_i) +X(cfg_rx1_pcs_bypass_usr_cdc_i) +X(cfg_rx1_pcs_comma_mask_i) +X(cfg_rx1_pcs_debug_en_i) +X(cfg_rx1_pcs_dec_bypass_i) +X(cfg_rx1_pcs_dscr_bypass_i) +X(cfg_rx1_pcs_el_buff_diff_bef_comp_i) +X(cfg_rx1_pcs_el_buff_max_comp_i) +X(cfg_rx1_pcs_el_buff_only_one_skp_i) +X(cfg_rx1_pcs_el_buff_skp_char_0_i) +X(cfg_rx1_pcs_el_buff_skp_char_1_i) +X(cfg_rx1_pcs_el_buff_skp_char_2_i) +X(cfg_rx1_pcs_el_buff_skp_char_3_i) +X(cfg_rx1_pcs_el_buff_skp_header_0_i) +X(cfg_rx1_pcs_el_buff_skp_header_1_i) +X(cfg_rx1_pcs_el_buff_skp_header_2_i) +X(cfg_rx1_pcs_el_buff_skp_header_3_i) +X(cfg_rx1_pcs_el_buff_skp_header_size_i) +X(cfg_rx1_pcs_el_buff_skp_seq_size_i) +X(cfg_rx1_pcs_fsm_sel_i) +X(cfg_rx1_pcs_fsm_watchdog_en_i) +X(cfg_rx1_pcs_loopback_i) +X(cfg_rx1_pcs_m_comma_en_i) +X(cfg_rx1_pcs_m_comma_val_i) +X(cfg_rx1_pcs_nb_comma_bef_realign_i) +X(cfg_rx1_pcs_p_comma_en_i) +X(cfg_rx1_pcs_p_comma_val_i) +X(cfg_rx1_pcs_polarity_i) +X(cfg_rx1_pcs_protocol_size_i) +X(cfg_rx1_pcs_replace_bypass_i) +X(cfg_rx1_pcs_sync_supported_i) +X(cfg_rx1_pma_cdr_cp_i) +X(cfg_rx1_pma_clk_pos_i) +X(cfg_rx1_pma_coarse_ppm_i) +X(cfg_rx1_pma_ctrl_term_i) +X(cfg_rx1_pma_dco_divl_i) +X(cfg_rx1_pma_dco_divm_i) +X(cfg_rx1_pma_dco_divn_i) +X(cfg_rx1_pma_dco_reg_res_i) +X(cfg_rx1_pma_dco_vref_sel_i) +X(cfg_rx1_pma_fine_ppm_i) +X(cfg_rx1_pma_loopback_i) +X(cfg_rx1_pma_m_eye_ppm_i) +X(cfg_rx1_pma_peak_detect_cmd_i) +X(cfg_rx1_pma_peak_detect_on_i) +X(cfg_rx1_pma_pll_cpump_n_i) +X(cfg_rx1_pma_pll_divf_en_n_i) +X(cfg_rx1_pma_pll_divf_i) +X(cfg_rx1_pma_pll_divm_en_n_i) +X(cfg_rx1_pma_pll_divm_i) +X(cfg_rx1_pma_pll_divn_en_n_i) +X(cfg_rx1_pma_pll_divn_i) +X(cfg_rx2_gearbox_en_i) +X(cfg_rx2_gearbox_mode_i) +X(cfg_rx2_pcs_8b_dscr_sel_i) +X(cfg_rx2_pcs_align_bypass_i) +X(cfg_rx2_pcs_buffers_bypass_i) +X(cfg_rx2_pcs_buffers_use_cdc_i) +X(cfg_rx2_pcs_bypass_pma_cdc_i) +X(cfg_rx2_pcs_bypass_usr_cdc_i) +X(cfg_rx2_pcs_comma_mask_i) +X(cfg_rx2_pcs_debug_en_i) +X(cfg_rx2_pcs_dec_bypass_i) +X(cfg_rx2_pcs_dscr_bypass_i) +X(cfg_rx2_pcs_el_buff_diff_bef_comp_i) +X(cfg_rx2_pcs_el_buff_max_comp_i) +X(cfg_rx2_pcs_el_buff_only_one_skp_i) +X(cfg_rx2_pcs_el_buff_skp_char_0_i) +X(cfg_rx2_pcs_el_buff_skp_char_1_i) +X(cfg_rx2_pcs_el_buff_skp_char_2_i) +X(cfg_rx2_pcs_el_buff_skp_char_3_i) +X(cfg_rx2_pcs_el_buff_skp_header_0_i) +X(cfg_rx2_pcs_el_buff_skp_header_1_i) +X(cfg_rx2_pcs_el_buff_skp_header_2_i) +X(cfg_rx2_pcs_el_buff_skp_header_3_i) +X(cfg_rx2_pcs_el_buff_skp_header_size_i) +X(cfg_rx2_pcs_el_buff_skp_seq_size_i) +X(cfg_rx2_pcs_fsm_sel_i) +X(cfg_rx2_pcs_fsm_watchdog_en_i) +X(cfg_rx2_pcs_loopback_i) +X(cfg_rx2_pcs_m_comma_en_i) +X(cfg_rx2_pcs_m_comma_val_i) +X(cfg_rx2_pcs_nb_comma_bef_realign_i) +X(cfg_rx2_pcs_p_comma_en_i) +X(cfg_rx2_pcs_p_comma_val_i) +X(cfg_rx2_pcs_polarity_i) +X(cfg_rx2_pcs_protocol_size_i) +X(cfg_rx2_pcs_replace_bypass_i) +X(cfg_rx2_pcs_sync_supported_i) +X(cfg_rx2_pma_cdr_cp_i) +X(cfg_rx2_pma_clk_pos_i) +X(cfg_rx2_pma_coarse_ppm_i) +X(cfg_rx2_pma_ctrl_term_i) +X(cfg_rx2_pma_dco_divl_i) +X(cfg_rx2_pma_dco_divm_i) +X(cfg_rx2_pma_dco_divn_i) +X(cfg_rx2_pma_dco_reg_res_i) +X(cfg_rx2_pma_dco_vref_sel_i) +X(cfg_rx2_pma_fine_ppm_i) +X(cfg_rx2_pma_loopback_i) +X(cfg_rx2_pma_m_eye_ppm_i) +X(cfg_rx2_pma_peak_detect_cmd_i) +X(cfg_rx2_pma_peak_detect_on_i) +X(cfg_rx2_pma_pll_cpump_n_i) +X(cfg_rx2_pma_pll_divf_en_n_i) +X(cfg_rx2_pma_pll_divf_i) +X(cfg_rx2_pma_pll_divm_en_n_i) +X(cfg_rx2_pma_pll_divm_i) +X(cfg_rx2_pma_pll_divn_en_n_i) +X(cfg_rx2_pma_pll_divn_i) +X(cfg_rx3_gearbox_en_i) +X(cfg_rx3_gearbox_mode_i) +X(cfg_rx3_pcs_8b_dscr_sel_i) +X(cfg_rx3_pcs_align_bypass_i) +X(cfg_rx3_pcs_buffers_bypass_i) +X(cfg_rx3_pcs_buffers_use_cdc_i) +X(cfg_rx3_pcs_bypass_pma_cdc_i) +X(cfg_rx3_pcs_bypass_usr_cdc_i) +X(cfg_rx3_pcs_comma_mask_i) +X(cfg_rx3_pcs_debug_en_i) +X(cfg_rx3_pcs_dec_bypass_i) +X(cfg_rx3_pcs_dscr_bypass_i) +X(cfg_rx3_pcs_el_buff_diff_bef_comp_i) +X(cfg_rx3_pcs_el_buff_max_comp_i) +X(cfg_rx3_pcs_el_buff_only_one_skp_i) +X(cfg_rx3_pcs_el_buff_skp_char_0_i) +X(cfg_rx3_pcs_el_buff_skp_char_1_i) +X(cfg_rx3_pcs_el_buff_skp_char_2_i) +X(cfg_rx3_pcs_el_buff_skp_char_3_i) +X(cfg_rx3_pcs_el_buff_skp_header_0_i) +X(cfg_rx3_pcs_el_buff_skp_header_1_i) +X(cfg_rx3_pcs_el_buff_skp_header_2_i) +X(cfg_rx3_pcs_el_buff_skp_header_3_i) +X(cfg_rx3_pcs_el_buff_skp_header_size_i) +X(cfg_rx3_pcs_el_buff_skp_seq_size_i) +X(cfg_rx3_pcs_fsm_sel_i) +X(cfg_rx3_pcs_fsm_watchdog_en_i) +X(cfg_rx3_pcs_loopback_i) +X(cfg_rx3_pcs_m_comma_en_i) +X(cfg_rx3_pcs_m_comma_val_i) +X(cfg_rx3_pcs_nb_comma_bef_realign_i) +X(cfg_rx3_pcs_p_comma_en_i) +X(cfg_rx3_pcs_p_comma_val_i) +X(cfg_rx3_pcs_polarity_i) +X(cfg_rx3_pcs_protocol_size_i) +X(cfg_rx3_pcs_replace_bypass_i) +X(cfg_rx3_pcs_sync_supported_i) +X(cfg_rx3_pma_cdr_cp_i) +X(cfg_rx3_pma_clk_pos_i) +X(cfg_rx3_pma_coarse_ppm_i) +X(cfg_rx3_pma_ctrl_term_i) +X(cfg_rx3_pma_dco_divl_i) +X(cfg_rx3_pma_dco_divm_i) +X(cfg_rx3_pma_dco_divn_i) +X(cfg_rx3_pma_dco_reg_res_i) +X(cfg_rx3_pma_dco_vref_sel_i) +X(cfg_rx3_pma_fine_ppm_i) +X(cfg_rx3_pma_loopback_i) +X(cfg_rx3_pma_m_eye_ppm_i) +X(cfg_rx3_pma_peak_detect_cmd_i) +X(cfg_rx3_pma_peak_detect_on_i) +X(cfg_rx3_pma_pll_cpump_n_i) +X(cfg_rx3_pma_pll_divf_en_n_i) +X(cfg_rx3_pma_pll_divf_i) +X(cfg_rx3_pma_pll_divm_en_n_i) +X(cfg_rx3_pma_pll_divm_i) +X(cfg_rx3_pma_pll_divn_en_n_i) +X(cfg_rx3_pma_pll_divn_i) +X(cfg_test_mode_i) +X(cfg_tx0_gearbox_en_i) +X(cfg_tx0_gearbox_mode_i) +X(cfg_tx0_pcs_8b_scr_sel_i) +X(cfg_tx0_pcs_bypass_pma_cdc_i) +X(cfg_tx0_pcs_bypass_usr_cdc_i) +X(cfg_tx0_pcs_enc_bypass_i) +X(cfg_tx0_pcs_esistream_fsm_en_i) +X(cfg_tx0_pcs_loopback_i) +X(cfg_tx0_pcs_polarity_i) +X(cfg_tx0_pcs_protocol_size_i) +X(cfg_tx0_pcs_replace_bypass_i) +X(cfg_tx0_pcs_scr_bypass_i) +X(cfg_tx0_pcs_scr_init_i) +X(cfg_tx0_pcs_sync_supported_i) +X(cfg_tx0_pma_clk_pos_i) +X(cfg_tx0_pma_loopback_i) +X(cfg_tx1_gearbox_en_i) +X(cfg_tx1_gearbox_mode_i) +X(cfg_tx1_pcs_8b_scr_sel_i) +X(cfg_tx1_pcs_bypass_pma_cdc_i) +X(cfg_tx1_pcs_bypass_usr_cdc_i) +X(cfg_tx1_pcs_enc_bypass_i) +X(cfg_tx1_pcs_esistream_fsm_en_i) +X(cfg_tx1_pcs_loopback_i) +X(cfg_tx1_pcs_polarity_i) +X(cfg_tx1_pcs_protocol_size_i) +X(cfg_tx1_pcs_replace_bypass_i) +X(cfg_tx1_pcs_scr_bypass_i) +X(cfg_tx1_pcs_scr_init_i) +X(cfg_tx1_pcs_sync_supported_i) +X(cfg_tx1_pma_clk_pos_i) +X(cfg_tx1_pma_loopback_i) +X(cfg_tx2_gearbox_en_i) +X(cfg_tx2_gearbox_mode_i) +X(cfg_tx2_pcs_8b_scr_sel_i) +X(cfg_tx2_pcs_bypass_pma_cdc_i) +X(cfg_tx2_pcs_bypass_usr_cdc_i) +X(cfg_tx2_pcs_enc_bypass_i) +X(cfg_tx2_pcs_esistream_fsm_en_i) +X(cfg_tx2_pcs_loopback_i) +X(cfg_tx2_pcs_polarity_i) +X(cfg_tx2_pcs_protocol_size_i) +X(cfg_tx2_pcs_replace_bypass_i) +X(cfg_tx2_pcs_scr_bypass_i) +X(cfg_tx2_pcs_scr_init_i) +X(cfg_tx2_pcs_sync_supported_i) +X(cfg_tx2_pma_clk_pos_i) +X(cfg_tx2_pma_loopback_i) +X(cfg_tx3_gearbox_en_i) +X(cfg_tx3_gearbox_mode_i) +X(cfg_tx3_pcs_8b_scr_sel_i) +X(cfg_tx3_pcs_bypass_pma_cdc_i) +X(cfg_tx3_pcs_bypass_usr_cdc_i) +X(cfg_tx3_pcs_enc_bypass_i) +X(cfg_tx3_pcs_esistream_fsm_en_i) +X(cfg_tx3_pcs_loopback_i) +X(cfg_tx3_pcs_polarity_i) +X(cfg_tx3_pcs_protocol_size_i) +X(cfg_tx3_pcs_replace_bypass_i) +X(cfg_tx3_pcs_scr_bypass_i) +X(cfg_tx3_pcs_scr_init_i) +X(cfg_tx3_pcs_sync_supported_i) +X(cfg_tx3_pma_clk_pos_i) +X(cfg_tx3_pma_loopback_i) +//X(location) +X(rx_usrclk_use_pcs_clk_2) +X(tx_usrclk_use_pcs_clk_2) + +// NX_IOB +X(NX_IOB) +//X(differential) +//X(drive) +X(dynDrive) +X(dynInput) +X(dynTerm) +X(extra) +//X(inputDelayLine) +X(inputDelayOn) +//X(inputSignalSlope) +//X(location) +//X(locked) +X(outputCapacity) +X(outputDelayLine) +X(outputDelayOn) +X(slewRate) +//X(standard) +//X(termination) +//X(terminationReference) +//X(turbo) +//X(weakTermination) + +// NX_IOB_I +X(NX_IOB_I) +//X(differential) +//X(drive) +//X(dynDrive) +//X(dynInput) +//X(dynTerm) +//X(extra) +//X(inputDelayLine) +//X(inputDelayOn) +//X(inputSignalSlope) +//X(location) +//X(locked) +//X(outputCapacity) +//X(outputDelayLine) +//X(outputDelayOn) +//X(slewRate) +//X(standard) +//X(termination) +//X(terminationReference) +//X(turbo) +//X(weakTermination) + +// NX_IOB_O +X(NX_IOB_O) +//X(differential) +//X(drive) +//X(dynDrive) +//X(dynInput) +//X(dynTerm) +//X(extra) +//X(inputDelayLine) +//X(inputDelayOn) +//X(inputSignalSlope) +//X(location) +//X(locked) +//X(outputCapacity) +//X(outputDelayLine) +//X(outputDelayOn) +//X(slewRate) +//X(standard) +//X(termination) +//X(terminationReference) +//X(turbo) +//X(weakTermination) + +// NX_IOM +X(NX_IOM) +X(div_rx1) +X(div_rx2) +X(div_tx1) +X(div_tx2) +X(mode_io_cal) +X(mode_side1) +X(mode_side2) +X(pads_dict) +X(pads_path) +X(sel_clk_out1) +X(sel_clk_out2) +X(sel_clkr_rx1) +X(sel_clkr_rx2) +X(sel_clkw_rx1) +X(sel_clkw_rx2) + +// NX_IOM_BIN2GRP +X(NX_IOM_BIN2GRP) + +// NX_IOM_CONTROL +X(NX_IOM_CONTROL) +//X(div_rx1) +//X(div_rx2) +//X(div_tx1) +//X(div_tx2) +X(inv_di_fclk1) +X(inv_di_fclk2) +X(latency1) +X(latency2) +//X(location) +X(mode_cpath) +X(mode_epath) +//X(mode_io_cal) +X(mode_rpath) +//X(mode_side1) +//X(mode_side2) +X(mode_tpath) +//X(sel_clk_out1) +//X(sel_clk_out2) +//X(sel_clkr_rx1) +//X(sel_clkr_rx2) +//X(sel_clkw_rx1) +//X(sel_clkw_rx2) + +// NX_IOM_CONTROL_L +X(NX_IOM_CONTROL_L) +//X(div_rx1) +//X(div_rx2) +//X(div_tx1) +//X(div_tx2) +//X(inv_di_fclk1) +//X(inv_di_fclk2) +//X(latency1) +//X(latency2) +//X(location) +//X(mode_cpath) +//X(mode_epath) +//X(mode_io_cal) +//X(mode_rpath) +//X(mode_side1) +//X(mode_side2) +//X(mode_tpath) +//X(sel_clk_out1) +//X(sel_clk_out2) +//X(sel_clkr_rx1) +//X(sel_clkr_rx2) +//X(sel_clkw_rx1) +//X(sel_clkw_rx2) + +// NX_IOM_CONTROL_M +X(NX_IOM_CONTROL_M) +//X(div_rx1) +//X(div_rx2) +//X(div_tx1) +//X(div_tx2) +//X(inv_di_fclk1) +//X(inv_di_fclk2) +//X(latency1) +//X(latency2) +//X(location) +//X(mode_cpath) +//X(mode_epath) +//X(mode_io_cal) +//X(mode_rpath) +//X(mode_side1) +//X(mode_side2) +//X(mode_tpath) +//X(sel_clk_out1) +//X(sel_clk_out2) +//X(sel_clkr_rx1) +//X(sel_clkr_rx2) +//X(sel_clkw_rx1) +//X(sel_clkw_rx2) + +// NX_IOM_CONTROL_U +X(NX_IOM_CONTROL_U) +X(cal_delay1) +X(cal_delay2) +X(div1) +X(div2) +X(div3) +X(div_swrx1) +X(div_swrx2) +X(inv_ld_sck1) +X(inv_ld_sck2) +X(inv_ld_sck3) +X(link_ld_12) +X(link_ld_23) +//X(location) +//X(mode_side1) +//X(mode_side2) +X(mode_side3) +//X(sel_clk_out1) +//X(sel_clk_out2) +X(sel_dc_clk) +X(sel_ld_fck1) +X(sel_ld_fck2) +X(sel_ld_fck3) +X(sel_sw_fck1) +X(sel_sw_fck2) +X(use_dc) + +// NX_IOM_DRIVER +X(NX_IOM_DRIVER) +X(chained) +X(cpath_edge) +X(cpath_init) +X(cpath_inv) +X(cpath_load) +X(cpath_mode) +X(cpath_sync) +X(epath_dynamic) +X(epath_edge) +X(epath_init) +X(epath_load) +X(epath_mode) +X(epath_sync) +//X(location) +X(rpath_dynamic) +X(rpath_edge) +X(rpath_init) +X(rpath_load) +X(rpath_mode) +X(rpath_sync) +X(symbol) +X(tpath_mode) +X(variant) + +// NX_IOM_DRIVER_M +X(NX_IOM_DRIVER_M) +//X(chained) +//X(cpath_edge) +//X(cpath_init) +//X(cpath_inv) +//X(cpath_load) +//X(cpath_mode) +//X(cpath_sync) +//X(epath_dynamic) +//X(epath_edge) +//X(epath_init) +//X(epath_load) +//X(epath_mode) +//X(epath_sync) +//X(location) +//X(rpath_dynamic) +//X(rpath_edge) +//X(rpath_init) +//X(rpath_load) +//X(rpath_mode) +//X(rpath_sync) +//X(symbol) +//X(tpath_mode) +//X(variant) + +// NX_IOM_DRIVER_U +X(NX_IOM_DRIVER_U) +//X(chained) +//X(cpath_edge) +//X(cpath_init) +//X(cpath_inv) +//X(cpath_load) +//X(cpath_mode) +//X(cpath_sync) +X(cpath_type) +//X(epath_dynamic) +//X(epath_edge) +//X(epath_init) +//X(epath_load) +//X(epath_mode) +//X(epath_sync) +X(epath_type) +//X(location) +//X(rpath_dynamic) +//X(rpath_edge) +//X(rpath_init) +//X(rpath_load) +//X(rpath_mode) +//X(rpath_sync) +X(rpath_type) +//X(symbol) +//X(tpath_mode) + +// NX_IOM_L +X(NX_IOM_L) +//X(div_rx1) +//X(div_rx2) +//X(div_tx1) +//X(div_tx2) +//X(mode_io_cal) +//X(mode_side1) +//X(mode_side2) +//X(pads_dict) +//X(pads_path) +//X(sel_clk_out1) +//X(sel_clk_out2) +//X(sel_clkr_rx1) +//X(sel_clkr_rx2) +//X(sel_clkw_rx1) +//X(sel_clkw_rx2) + +// NX_IOM_SERDES +X(NX_IOM_SERDES) +//X(data_size) +//X(location) + +// NX_IOM_SERDES_M +X(NX_IOM_SERDES_M) +//X(data_size) +//X(location) + +// NX_IOM_SERDES_U +X(NX_IOM_SERDES_U) +//X(data_size) +//X(location) + +// NX_IOM_U +X(NX_IOM_U) +//X(cal_delay1) +//X(cal_delay2) +//X(div1) +//X(div2) +//X(div3) +//X(div_swrx1) +//X(div_swrx2) +//X(inv_ld_sck1) +//X(inv_ld_sck2) +//X(inv_ld_sck3) +//X(link_ld_12) +//X(link_ld_23) +//X(mode_side1) +//X(mode_side2) +//X(mode_side3) +//X(pads_dict) +//X(pads_path) +//X(sel_clk_out1) +//X(sel_clk_out2) +//X(sel_dc_clk) +//X(sel_ld_fck1) +//X(sel_ld_fck2) +//X(sel_ld_fck3) +//X(sel_sw_fck1) +//X(sel_sw_fck2) +//X(use_dc) + +// NX_LUT +X(NX_LUT) +X(lut_table) + +// NX_PLL +X(NX_PLL) +X(clk_outdiv1) +X(clk_outdiv2) +X(clk_outdiv3) +X(ext_fbk_on) +X(fbk_delay) +X(fbk_delay_on) +X(fbk_div_on) +X(fbk_intdiv) +//X(location) +X(ref_div_on) +X(vco_range) + +// NX_PLL_L +X(NX_PLL_L) +X(cfg_use_pll) +X(clk_outdivo1) +X(clk_outdivp1) +X(clk_outdivp2) +X(clk_outdivp3o2) +//X(ext_fbk_on) +//X(fbk_delay) +//X(fbk_delay_on) +//X(fbk_intdiv) +//X(location) +X(pll_cpump) +X(ref_intdiv) +X(ref_osc_on) +X(wfg_sync_cal_lock) +X(wfg_sync_pll_lock) + +// NX_PLL_U +X(NX_PLL_U) +X(cal_delay) +X(cal_div) +X(clk_cal_sel) +//X(clk_outdiv1) +//X(clk_outdiv2) +//X(clk_outdiv3) +X(clk_outdiv4) +X(clk_outdivd1) +X(clk_outdivd2) +X(clk_outdivd3) +X(clk_outdivd4) +X(clk_outdivd5) +//X(ext_fbk_on) +//X(fbk_delay) +//X(fbk_delay_on) +//X(fbk_intdiv) +//X(location) +//X(pll_cpump) +X(pll_lock) +X(pll_lpf_cap) +X(pll_lpf_res) +X(pll_odf) +//X(ref_intdiv) +//X(ref_osc_on) +X(use_cal) +X(use_pll) + +// NX_PLL_U_WRAP +X(NX_PLL_U_WRAP) +//X(cal_delay) +//X(cal_div) +//X(clk_cal_sel) +//X(clk_outdiv1) +//X(clk_outdiv2) +//X(clk_outdiv3) +//X(clk_outdiv4) +//X(clk_outdivd1) +//X(clk_outdivd2) +//X(clk_outdivd3) +//X(clk_outdivd4) +//X(clk_outdivd5) +//X(ext_fbk_on) +//X(fbk_delay) +//X(fbk_delay_on) +//X(fbk_intdiv) +//X(location) +//X(pll_cpump) +//X(pll_lock) +//X(pll_lpf_cap) +//X(pll_lpf_res) +//X(pll_odf) +//X(ref_intdiv) +//X(ref_osc_on) +//X(use_cal) +//X(use_pll) + +// NX_PMA_L +X(NX_PMA_L) +//X(location) +X(main_clk_to_fabric_div_en) +X(main_clk_to_fabric_div_mode) +X(main_clk_to_fabric_sel) +X(main_test) +X(main_use_only_usr_clock) +X(main_use_pcs_clk_2) +X(pcs_ovs_mode) +X(pcs_pll_lock_count) +X(pcs_word_len) +X(pll_pma_cpump_n) +X(pll_pma_divf) +X(pll_pma_divf_en_n) +X(pll_pma_divm) +X(pll_pma_divm_en_n) +X(pll_pma_divn) +X(pll_pma_divn_en_n) +X(pll_pma_int_data_len) +X(pll_pma_lvds_mux) +X(pll_pma_mux_ckref) +X(rx_pma_half_step) + +// NX_PMA_U +X(NX_PMA_U) +X(dyn_all_rx_pma_m_eye) +X(dyn_all_rx_pma_m_eye_coarse_ena) +X(dyn_all_rx_pma_m_eye_dn) +X(dyn_all_rx_pma_m_eye_fine_ena) +X(dyn_all_rx_pma_m_eye_step) +X(dyn_all_rx_pma_m_eye_up) +X(dyn_all_rx_pma_threshold_1) +X(dyn_all_rx_pma_threshold_2) +X(dyn_all_rx_pma_trim_locked) +X(dyn_all_rx_pma_trim_mode) +X(dyn_all_rx_pma_trim_unlocked) +X(dyn_rx0_pma_ctle_cap_p) +X(dyn_rx0_pma_ctle_res_p) +X(dyn_rx0_pma_dfe_idac_tap1_n) +X(dyn_rx0_pma_dfe_idac_tap2_n) +X(dyn_rx0_pma_dfe_idac_tap3_n) +X(dyn_rx0_pma_dfe_idac_tap4_n) +X(dyn_rx0_pma_termination_cmd) +X(dyn_rx1_pma_ctle_cap_p) +X(dyn_rx1_pma_ctle_res_p) +X(dyn_rx1_pma_dfe_idac_tap1_n) +X(dyn_rx1_pma_dfe_idac_tap2_n) +X(dyn_rx1_pma_dfe_idac_tap3_n) +X(dyn_rx1_pma_dfe_idac_tap4_n) +X(dyn_rx1_pma_termination_cmd) +X(dyn_rx2_pma_ctle_cap_p) +X(dyn_rx2_pma_ctle_res_p) +X(dyn_rx2_pma_dfe_idac_tap1_n) +X(dyn_rx2_pma_dfe_idac_tap2_n) +X(dyn_rx2_pma_dfe_idac_tap3_n) +X(dyn_rx2_pma_dfe_idac_tap4_n) +X(dyn_rx2_pma_termination_cmd) +X(dyn_rx3_pma_ctle_cap_p) +X(dyn_rx3_pma_ctle_res_p) +X(dyn_rx3_pma_dfe_idac_tap1_n) +X(dyn_rx3_pma_dfe_idac_tap2_n) +X(dyn_rx3_pma_dfe_idac_tap3_n) +X(dyn_rx3_pma_dfe_idac_tap4_n) +X(dyn_rx3_pma_termination_cmd) +X(dyn_tx0_pma_main_en) +X(dyn_tx0_pma_main_sign) +X(dyn_tx0_pma_margin_input) +X(dyn_tx0_pma_margin_sel) +X(dyn_tx0_pma_post_en) +X(dyn_tx0_pma_post_sel) +X(dyn_tx0_pma_post_sign) +X(dyn_tx0_pma_pre_en) +X(dyn_tx0_pma_pre_sel) +X(dyn_tx0_pma_pre_sign) +X(dyn_tx1_pma_main_en) +X(dyn_tx1_pma_main_sign) +X(dyn_tx1_pma_margin_input) +X(dyn_tx1_pma_margin_sel) +X(dyn_tx1_pma_post_en) +X(dyn_tx1_pma_post_sel) +X(dyn_tx1_pma_post_sign) +X(dyn_tx1_pma_pre_en) +X(dyn_tx1_pma_pre_sel) +X(dyn_tx1_pma_pre_sign) +X(dyn_tx2_pma_main_en) +X(dyn_tx2_pma_main_sign) +X(dyn_tx2_pma_margin_input) +X(dyn_tx2_pma_margin_sel) +X(dyn_tx2_pma_post_en) +X(dyn_tx2_pma_post_sel) +X(dyn_tx2_pma_post_sign) +X(dyn_tx2_pma_pre_en) +X(dyn_tx2_pma_pre_sel) +X(dyn_tx2_pma_pre_sign) +X(dyn_tx3_pma_main_en) +X(dyn_tx3_pma_main_sign) +X(dyn_tx3_pma_margin_input) +X(dyn_tx3_pma_margin_sel) +X(dyn_tx3_pma_post_en) +X(dyn_tx3_pma_post_sel) +X(dyn_tx3_pma_post_sign) +X(dyn_tx3_pma_pre_en) +X(dyn_tx3_pma_pre_sel) +X(dyn_tx3_pma_pre_sign) +//X(location) +//X(main_clk_to_fabric_div_en) +//X(main_clk_to_fabric_div_mode) +//X(main_clk_to_fabric_sel) +X(main_rclk_to_fabric_sel) +//X(main_use_only_usr_clock) +X(pcs_ovs_en) +//X(pcs_ovs_mode) +X(pcs_pll_lock_ppm) +//X(pcs_word_len) +X(pll_pma_ckref_ext) +X(pll_pma_cpump) +X(pll_pma_divl) +//X(pll_pma_divm) +//X(pll_pma_divn) +X(pll_pma_gbx_en) +//X(pll_pma_int_data_len) +X(pll_pma_lvds_en) +//X(pll_pma_lvds_mux) +//X(pll_pma_mux_ckref) +//X(rx_usrclk_use_pcs_clk_2) +X(test_mode) +//X(tx_usrclk_use_pcs_clk_2) + +// NX_R5_L +X(NX_R5_L) + +// NX_R5_L_WRAP +X(NX_R5_L_WRAP) + +// NX_RAM +X(NX_RAM) +X(mcka_edge) +X(mckb_edge) +X(mem_ctxt) +X(pcka_edge) +X(pckb_edge) +X(pipe_ia) +X(pipe_ib) +X(pipe_oa) +X(pipe_ob) +//X(raw_config0) +//X(raw_config1) +X(raw_l_enable) +X(raw_l_extend) +X(raw_u_enable) +X(raw_u_extend) +//X(std_mode) + +// NX_RAM_SLOWECC_1K_36_1r1w +X(NX_RAM_SLOWECC_1K_36_1r1w) +//X(mem_ctxt) + +// NX_RAM_WRAP +X(NX_RAM_WRAP) +//X(mcka_edge) +//X(mckb_edge) +//X(mem_ctxt) +//X(pcka_edge) +//X(pckb_edge) +//X(pipe_ia) +//X(pipe_ib) +//X(pipe_oa) +//X(pipe_ob) +//X(raw_config0) +//X(raw_config1) +//X(raw_l_enable) +//X(raw_l_extend) +//X(raw_u_enable) +//X(raw_u_extend) +//X(std_mode) + +// NX_RB +X(NX_RB) +X(inputBypass) +X(inputClk) +X(inputContext) +X(outputBypass) +X(outputClk) +X(outputContext) + +// NX_RB_WRAP +X(NX_RB_WRAP) +//X(inputBypass) +//X(inputClk) +//X(inputContext) +//X(outputBypass) +//X(outputClk) +//X(outputContext) + +// NX_RFB +X(NX_RFB) +X(addr_mask) +//X(mem_ctxt) +//X(rck_edge) +//X(wck_edge) +X(we_mask) +X(wea_mask) + +// NX_RFBDP_U_WRAP +X(NX_RFBDP_U_WRAP) +//X(mem_ctxt) +//X(wck_edge) + +// NX_RFBSP_U_WRAP +X(NX_RFBSP_U_WRAP) +//X(mem_ctxt) +//X(wck_edge) + +// NX_RFB_L +X(NX_RFB_L) +//X(mem_ctxt) +//X(mode) +//X(rck_edge) +//X(wck_edge) + +// NX_RFB_L_WRAP +X(NX_RFB_L_WRAP) +//X(mem_ctxt) +//X(mode) +//X(rck_edge) +//X(wck_edge) + +// NX_RFB_M +X(NX_RFB_M) +//X(mem_ctxt) +//X(rck_edge) +//X(wck_edge) + +// NX_RFB_U +X(NX_RFB_U) +//X(mem_ctxt) +//X(mode) +//X(wck_edge) + +// NX_RFB_WRAP +X(NX_RFB_WRAP) +//X(mem_ctxt) +//X(rck_edge) +//X(wck_edge) + +// NX_SER +X(NX_SER) +//X(data_size) +//X(differential) +//X(drive) +//X(location) +//X(locked) +//X(outputCapacity) +//X(outputDelayLine) +//X(slewRate) +X(spath_dynamic) +//X(standard) + +// NX_SERDES +X(NX_SERDES) +X(cpath_registered) +//X(data_size) +//X(differential) +//X(dpath_dynamic) +//X(drive) +//X(inputDelayLine) +//X(inputSignalSlope) +//X(location) +//X(locked) +//X(outputCapacity) +//X(outputDelayLine) +//X(slewRate) +//X(spath_dynamic) +//X(standard) +//X(termination) +//X(terminationReference) +//X(turbo) +//X(weakTermination) + +// NX_WFG +X(NX_WFG) +X(delay) +X(delay_on) +//X(location) +//X(mode) +X(pattern) +X(pattern_end) +X(wfg_edge) + +// NX_WFG_L +X(NX_WFG_L) +//X(delay) +//X(delay_on) +//X(location) +//X(mode) +//X(pattern) +//X(pattern_end) +//X(wfg_edge) + +// NX_WFG_U +X(NX_WFG_U) +//X(delay) +//X(delay_on) +X(div_phase) +X(div_ratio) +//X(location) +//X(mode) +//X(pattern) +//X(pattern_end) +X(reset_on_cal_lock_n) +X(reset_on_pll_lock_n) +X(reset_on_pll_locka_n) +//X(wfg_edge) + +// NX_XCDC_U +X(NX_XCDC_U) +//X(ack_sel) +//X(bck_sel) +//X(cck_sel) +//X(ck0_edge) +//X(ck1_edge) +//X(dck_sel) +//X(link_BA) +//X(link_CB) +//X(link_DC) +//X(use_adest_arst) +//X(use_asrc_arst) +//X(use_bdest_arst) +//X(use_bsrc_arst) +//X(use_cdest_arst) +//X(use_csrc_arst) +//X(use_ddest_arst) +//X(use_dsrc_arst) + +// NX_XFIFO_32x36 +X(NX_XFIFO_32x36) +//X(rck_edge) +//X(read_addr_inv) +//X(use_read_arst) +//X(use_write_arst) +//X(wck_edge) + +// NX_XFIFO_64x18 +X(NX_XFIFO_64x18) +//X(rck_edge) +//X(read_addr_inv) +//X(use_read_arst) +//X(use_write_arst) +//X(wck_edge) + +// NX_XRFB_2R_1W +X(NX_XRFB_2R_1W) +//X(mem_ctxt) +//X(wck_edge) + +// NX_XRFB_32x36 +X(NX_XRFB_32x36) +//X(mem_ctxt) +//X(wck_edge) + +// NX_XRFB_64x18 +X(NX_XRFB_64x18) +//X(mem_ctxt) +//X(wck_edge) + +// end of generated parameter list + +// IO location attribute +X(LOC) + +X(lut_used) +X(dff_used) + diff --git a/himbaechel/uarch/ng-ultra/csv.cc b/himbaechel/uarch/ng-ultra/csv.cc new file mode 100644 index 00000000..00d84499 --- /dev/null +++ b/himbaechel/uarch/ng-ultra/csv.cc @@ -0,0 +1,212 @@ +/* + * nextpnr -- Next Generation Place and Route + * + * Copyright (C) 2024 Miodrag Milanovic + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + */ + +#include +#include +#include +#include + +#include "extra_data.h" +#include "himbaechel_api.h" +#include "log.h" +#include "nextpnr.h" +#include "util.h" + +#include "ng_ultra.h" + +#define HIMBAECHEL_CONSTIDS "uarch/ng-ultra/constids.inc" +#include "himbaechel_constids.h" + +NEXTPNR_NAMESPACE_BEGIN + +void NgUltraImpl::parse_csv(const std::string &filename) +{ + std::ifstream in(filename); + if (!in) + log_error("failed to open CSV file '%s'\n", filename.c_str()); + log_info("Parsing CSV file..\n"); + std::string line; + std::string linebuf; + int lineno = 0; + enum uint8_t + { + IO_PADS = 0, + IO_BANKS, + IO_GCKS, + IO_ERROR + } line_type; + + auto isempty = [](const std::string &str) { + return std::all_of(str.begin(), str.end(), [](char c) { return std::isspace(c); }); + }; + auto is_number = [](const std::string &str) { + return !str.empty() && std::all_of(str.begin(), str.end(), ::isdigit); + }; + auto get_cells = [&](std::string str) { + std::vector tgt_cells; + IdString cellname = ctx->id(str); + if (ctx->cells.count(cellname)) + tgt_cells.push_back(ctx->cells.at(cellname).get()); + return tgt_cells; + }; + + line_type = IO_PADS; + pool banks_used; + while (std::getline(in, line)) { + ++lineno; + // Trim comments, from # until end of the line + size_t cstart = line.find('#'); + if (cstart != std::string::npos) + line = line.substr(0, cstart); + if (isempty(line)) + continue; + + std::vector arguments; + boost::split(arguments, line, boost::is_any_of(",")); + if (arguments.empty()) + continue; + switch(line_type) { + case IO_PADS: + { + if (arguments.size()==1 && arguments[0][0]=='!') { + line_type = IO_BANKS; + continue; + } + if (arguments.size()!=15) + log_error("number of parameters in line %d must be 15\n", lineno); + + if (!(boost::starts_with(arguments.at(1), "IOB") && boost::contains(arguments.at(1),"_D"))) + log_error("invalid location name '%s' must start with 'IOB' in line %d\n", arguments.at(1).c_str(), lineno); + + const char* standard_values[] = { "LVDS", "LVCMOS", "SSTL", "HSTL" }; + auto it = std::find(std::begin(standard_values),std::end(standard_values), arguments.at(2)); + if (it == std::end(standard_values)) + log_error("unknown standard value '%s' in line %d\n", arguments.at(2).c_str(), lineno); + + const char* drive_values[] = { "2mA", "4mA", "8mA", "16mA", "I", "II" }; + it = std::find(std::begin(drive_values),std::end(drive_values), arguments.at(3)); + if (it == std::end(drive_values)) + log_error("unknown drive value '%s' in line %d\n", arguments.at(3).c_str(), lineno); + + const char* weak_values[] = { "None", "PullDown", "PullUp", "Keeper" }; + it = std::find(std::begin(weak_values),std::end(weak_values), arguments.at(4)); + if (it == std::end(weak_values)) + log_error("unknown weak termination value '%s' in line %d\n", arguments.at(4).c_str(), lineno); + + const char* slew_values[] = { "Slow", "Medium", "Fast" }; + it = std::find(std::begin(slew_values),std::end(slew_values), arguments.at(5)); + if (it == std::end(slew_values)) + log_error("unknown weak termination value '%s' in line %d\n", arguments.at(5).c_str(), lineno); + + if (!arguments.at(6).empty() && !is_number(arguments.at(6))) + log_error("termination must be string containing int, value '%s' in line %d\n", arguments.at(6).c_str(), lineno); + + if (!arguments.at(7).empty() && !is_number(arguments.at(7))) + log_error("input delay must be number, value '%s' in line %d\n", arguments.at(7).c_str(), lineno); + if (!arguments.at(8).empty() && !is_number(arguments.at(8))) + log_error("output delay must be number, value '%s' in line %d\n", arguments.at(8).c_str(), lineno); + + if (!arguments.at(9).empty() && arguments.at(9) != "True" && arguments.at(9) != "False") + log_error("differential must be boolean, value '%s' in line %d\n", arguments.at(9).c_str(), lineno); + + const char* termref_values[] = { "Floating", "VT" }; + it = std::find(std::begin(termref_values),std::end(termref_values), arguments.at(10)); + if (it == std::end(termref_values)) + log_error("unknown termination reference value '%s' in line %d\n", arguments.at(10).c_str(), lineno); + + if (!arguments.at(11).empty() && arguments.at(11) != "True" && arguments.at(11) != "False") + log_error("turbo must be boolean, value '%s' in line %d\n", arguments.at(11).c_str(), lineno); + + if (!arguments.at(12).empty() && !is_number(arguments.at(12))) + log_error("signal slope must be number, value '%s' in line %d\n", arguments.at(12).c_str(), lineno); + if (!arguments.at(13).empty() && !is_number(arguments.at(13))) + log_error("output capacity must be number, value '%s' in line %d\n", arguments.at(13).c_str(), lineno); + + const char* registered_values[] = { "Auto", "I", "IC", "O", "OC", "IO", "IOC" }; + it = std::find(std::begin(registered_values),std::end(registered_values), arguments.at(14)); + if (it == std::end(registered_values)) + log_error("unknown registered value '%s' in line %d\n", arguments.at(14).c_str(), lineno); + + std::vector dest = get_cells(arguments.at(0)); + for (auto c : dest) { + c->attrs[id_LOC] = arguments.at(1); + c->params[ctx->id("iobname")] = arguments.at(0); + c->params[ctx->id("standard")] = arguments.at(2); + c->params[ctx->id("drive")] = arguments.at(3); + c->params[ctx->id("weakTermination")] = arguments.at(4); + c->params[ctx->id("slewRate")] = arguments.at(5); + c->params[ctx->id("termination")] = arguments.at(6); + c->params[ctx->id("inputDelayLine")] = arguments.at(7); + c->params[ctx->id("outputDelayLine")] = arguments.at(8); + c->params[ctx->id("differential")] = arguments.at(9); + c->params[ctx->id("terminationReference")] = arguments.at(10); + c->params[ctx->id("turbo")] = arguments.at(11); + c->params[ctx->id("inputSignalSlope")] = arguments.at(12); + c->params[ctx->id("outputCapacity")] = arguments.at(13); + //c->params[ctx->id("IO_PATH")] = arguments.at(14); + } + if (dest.size()==0) + log_warning("Pad with name '%s' not found in netlist.\n", arguments.at(0).c_str()); + + std::string bank_name = arguments.at(1).substr(0,arguments.at(1).find_first_of('_')); + banks_used.emplace(bank_name); + } + break; + case IO_BANKS: + { + if (arguments.size()==1 && arguments[0][0]=='!') { + line_type = IO_GCKS; + continue; + } + if (arguments.size()!=3) + log_error("number of parameters in line %d must be 3\n", lineno); + + if (!boost::starts_with(arguments.at(0), "IOB")) + log_error("wrong bank name '%s' in line %d\n", arguments.at(0).c_str(), lineno); + + const char* voltages[] = { "1.5V", "1.8V", "2.5V", "3.3V" }; + auto it = std::find(std::begin(voltages),std::end(voltages), arguments.at(1)); + if (it == std::end(voltages)) + log_error("unknown voltage level '%s' in line %d\n", arguments.at(1).c_str(), lineno); + + bank_voltage[arguments.at(0)] = arguments.at(1); + } + break; + case IO_GCKS: + { + if (arguments.size()==1 && arguments[0][0]=='!') { + line_type = IO_ERROR; + continue; + } + if (arguments.size()!=2) + log_error("number of parameters in line %d must be 2\n", lineno); + } + break; + default: + log_error("switching to unknown block of data in line %d\n", lineno); + } + } + for(auto& bank_name : banks_used) { + if (bank_voltage.count(bank_name) == 0) { + log_error("IO for bank '%s' defined, but no bank configuration.\n", bank_name.c_str()); + } + } +} + +NEXTPNR_NAMESPACE_END diff --git a/himbaechel/uarch/ng-ultra/extra_data.h b/himbaechel/uarch/ng-ultra/extra_data.h new file mode 100644 index 00000000..a70e9289 --- /dev/null +++ b/himbaechel/uarch/ng-ultra/extra_data.h @@ -0,0 +1,65 @@ +#ifndef NGULTRA_EXTRA_DATA_H +#define NGULTRA_EXTRA_DATA_H + +#include "nextpnr.h" + +NEXTPNR_NAMESPACE_BEGIN + +NPNR_PACKED_STRUCT(struct NGUltraTileInstExtraDataPOD { + int32_t name; + uint8_t lobe; + uint8_t dummy1; + uint16_t dummy2; +}); + +NPNR_PACKED_STRUCT(struct NGUltraPipExtraDataPOD { + int32_t name; + uint16_t type; + uint8_t input; + uint8_t output; +}); + +NPNR_PACKED_STRUCT(struct NGUltraBelExtraDataPOD { int32_t flags; }); + +enum TILETypeZ +{ + BEL_LUT_Z = 0, + BEL_LUT_MAX_Z = 31, + BEL_CY_Z = 32, + BEL_XLUT_Z = BEL_CY_Z + 4, + BEL_RF_Z = BEL_XLUT_Z + 8, + BEL_XRF_Z = BEL_RF_Z + 2, + BEL_FIFO_Z = BEL_XRF_Z + 1, + BEL_XFIFO_Z = BEL_FIFO_Z + 2, + BEL_CDC_Z = BEL_XFIFO_Z + 1, + BEL_XCDC_Z = BEL_CDC_Z + 2 +}; + +enum ClusterPlacement +{ + PLACE_CY_CHAIN = 1024, + PLACE_CY_FE1, + PLACE_CY_FE2, + PLACE_CY_FE3, + PLACE_CY_FE4, +}; + +enum PipExtra +{ + PIP_EXTRA_CROSSBAR = 1, + PIP_EXTRA_MUX = 2, + PIP_EXTRA_BYPASS = 3, + PIP_EXTRA_LUT_PERMUTATION = 4, + PIP_EXTRA_INTERCONNECT = 5, + PIP_EXTRA_VIRTUAL = 6, +}; + +enum BelExtra +{ + BEL_EXTRA_FE_CSC = 1, + BEL_EXTRA_FE_SCC = 2, +}; + +NEXTPNR_NAMESPACE_END + +#endif diff --git a/himbaechel/uarch/ng-ultra/gen/arch_gen.py b/himbaechel/uarch/ng-ultra/gen/arch_gen.py new file mode 100644 index 00000000..14295736 --- /dev/null +++ b/himbaechel/uarch/ng-ultra/gen/arch_gen.py @@ -0,0 +1,675 @@ +import json +from os import path +import sys +import argparse +import gzip + +# Configuration flags +USE_LUT_PERMUTATION = True + +sys.path.append(path.join(path.dirname(__file__), "../../..")) +from himbaechel_dbgen.chip import * + +@dataclass +class TileExtraData(BBAStruct): + name: IdString + lobe: int = 0 + + def serialise_lists(self, context: str, bba: BBAWriter): + pass + def serialise(self, context: str, bba: BBAWriter): + bba.u32(self.name.index) + bba.u8(self.lobe) + bba.u8(0) # dummy + bba.u16(0) # dummy + +@dataclass +class PipExtraData(BBAStruct): + name: IdString = field(default_factory=IdString) + data_type: int = 0 + input: int = 0 + output: int = 0 + + def serialise_lists(self, context: str, bba: BBAWriter): + pass + def serialise(self, context: str, bba: BBAWriter): + bba.u32(self.name.index) + bba.u16(self.data_type) + bba.u8(self.input) + bba.u8(self.output) + +@dataclass +class BelExtraData(BBAStruct): + flags: int = 0 + + def serialise_lists(self, context: str, bba: BBAWriter): + pass + def serialise(self, context: str, bba: BBAWriter): + bba.u32(self.flags) + +PLL_Z = 0 +WFG_C_Z = 1 +WFG_R_Z = 11 + +IOM_Z = 136 + +RAM_Z = 0 +DSP1_Z = 1 +DSP2_Z = 2 + +SOCIF_Z = 0 +SERVICE_Z = 1 + +LUT_Z = 0 +CY_Z = 32 +XLUT_Z = CY_Z + 4 +RF_Z = XLUT_Z + 8 +XRF_Z = RF_Z + 2 +FIFO_Z = XRF_Z + 1 +XFIFO_Z = FIFO_Z + 2 +CDC_Z = XFIFO_Z + 1 +XCDC_Z = CDC_Z + 2 + +PIP_EXTRA_CROSSBAR = 1 +PIP_EXTRA_MUX = 2 +PIP_EXTRA_BYPASS = 3 +PIP_EXTRA_LUT_PERMUTATION = 4 +PIP_EXTRA_INTERCONNECT = 5 +PIP_EXTRA_VIRTUAL = 6 + +BEL_EXTRA_FE_CSC = 1 +BEL_EXTRA_FE_SCC = 2 + +def bel_z(tile_type, bel_name, bel_type): + if tile_type.startswith("CKG"): + if (bel_type=="PLL"): + return PLL_Z + else: + if bel_name.startswith("WFG.WFG_C"): + return int(bel_name.replace("WFG.WFG_C","")) + WFG_C_Z -1 + else: + return int(bel_name.replace("WFG.WFG_R","")) + WFG_R_Z -1 + elif tile_type.startswith("HSSL"): + if bel_type=="PMA": + return 0 + elif bel_type=="CRX": + return int(bel_name.split(".")[0][7:]) * 2 - 1 + else: + return int(bel_name.split(".")[0][7:]) * 2 + elif tile_type.startswith("IOB") and tile_type in ["IOB0","IOB1","IOB6","IOB7"]: #direct + sp = bel_name.split(".") + if bel_type=="IOP": + return int(sp[0][1:]) * 4 + else: + return (int(sp[0][3:])-1) * 4 + (1 if sp[1][0]=='I' else 2 if sp[1][0]=='O' else 3) + elif tile_type.startswith("IOB"): # complex + sp = bel_name.split(".") + if bel_type=="IOTP": + return (int(sp[0][1:3]) *2 + (1 if sp[0][3]=='N' else 0)) * 4 + elif bel_type=="IOM": + return IOM_Z + else: + return (int(sp[0][3:])-1) * 4 + (1 if sp[1][0]=='I' else 2 if sp[1][0]=='O' else 3) + elif tile_type == "CGB": + if bel_type=="RAM": + return RAM_Z + elif bel_name=="S2.DSP1": + return DSP1_Z + else: + return DSP2_Z + elif tile_type == "SOCBank": + if bel_type=="SOCIF": + return SOCIF_Z + else: + return SERVICE_Z + elif tile_type == "TILE": + sp = bel_name.split(".") + if bel_type=="BEYOND_FE": + return (int(sp[1][2:])-1) % 32 + elif bel_type=="CY": + pos = int(sp[1][2:])-1 + # in S1, S5 and S9 they are ordered other way arround + return ((pos % 4) if pos < 12 else 3 - (pos % 4)) + CY_Z + elif bel_type=="XLUT": + return (int(sp[1][4:])-1) % 8 + XLUT_Z + elif bel_type=="RF": + return (int(sp[1][2:])-1) + RF_Z + elif bel_type=="XRF": + return (int(sp[1][3:])-1) + XRF_Z + elif bel_type=="FIFO": + return (int(sp[1][4:])-1) + FIFO_Z + elif bel_type=="XFIFO": + return (int(sp[1][5:])-1) + XFIFO_Z + elif bel_type=="CDC": + return (int(sp[1][3:])-1) + CDC_Z + elif bel_type=="XCDC": + return (int(sp[1][4:])-1) + XCDC_Z + else: + raise Exception(f"Unknown bel type {bel_type}") + elif tile_type == "TUBE": + sp = bel_name.split(".") + return (int(sp[0][1:])-1)*20 + (int(sp[1][1:])-1) + else: + raise Exception(f"Unknown type {tile_type}") + +if USE_LUT_PERMUTATION: + # Note PI1-PI4 are not real inputs but will appear + # before actual BEL input to enable LUT permutation + lut_to_beyond_fe = { + "I1" : "PI1", + "I2" : "PI2", + "I3" : "PI3", + "I4" : "PI4", + "O" : "LO", + "J" : "LJ", + "K" : "LK", + "D" : "LD", + "X" : "LX", + } +else: + lut_to_beyond_fe = { + "I1" : "I1", + "I2" : "I2", + "I3" : "I3", + "I4" : "I4", + "O" : "LO", + "J" : "LJ", + "K" : "LK", + "D" : "LD", + "X" : "LX", + } + +dff_to_beyond_fe = { + "I" : "DI", + "O" : "DO", + "L" : "L", + "CK" : "CK", + "R" : "R", + "J" : "DJ", + "P" : "DP", + "C" : "DC", + "S" : "DS", + "K" : "DK", +} + +def is_complex(tile_type): + return tile_type not in ["IOB0","IOB1","IOB6","IOB7"] + +def map_to_beyond(tile_type,bel_name,bel_type=None): + if not tile_type in ["TILE"]: + return (bel_name,bel_type) + s = bel_name.split(".") + if tile_type in ["TILE"]: + # BEYOND_FE + if not (s[1].startswith("LUT") or s[1].startswith("DFF")): + return (bel_name,bel_type) + if len(s)==3: + # BEL and PORT + if s[1].startswith("LUT"): + pin = lut_to_beyond_fe[s[2]] + else: + pin = dff_to_beyond_fe[s[2]] + if pin is None: + return (None,bel_type) + return (s[0]+".FE"+s[1][3:]+"."+pin, bel_type if type(bel_type) is int else "BEYOND_FE") + else: + # just BEL + return (s[0]+".FE"+s[1][3:], "BEYOND_FE") + +split_map = ["TILE", "CGB"] + +def split_tilegrid(tilegrid): + new_tilegrid = dict() + for k,v in tilegrid.items(): + if v["type"] not in split_map: + new_tilegrid[k] = dict() + data = dict(v) + data["orig"] = data["type"] + data["x"]=data["x"]*4 + data["y"]=data["y"]*4 + new_tilegrid[k][0] = data + else: + new_tilegrid[k] = dict() + for i in range(4*4): + data = dict(v) + data["orig"] = data["type"] + data["type"] = data["type"]+"_"+str(i) + data["x"]=data["x"]*4 + i // 4 + data["y"]=data["y"]*4 + i % 4 + new_tilegrid[k][i] = data + return new_tilegrid + +def determine_subtile(tile,bel): + if tile=="TILE": + if bel.startswith("SYSTEM"): + s = 3 + elif bel.startswith("RE") or bel.startswith("RS") or bel.startswith("RI"): + s = int(bel.split(".")[0][2:])-1 + elif bel.startswith("S"): + s = int(bel.split(".")[0][1:])+3 + else: + return 0 + return s + elif tile=="CGB": + if bel.startswith("SYSTEM"): + s = 6 + elif bel.startswith("RE"): + s = 8 + elif bel.startswith("RS"): + s = int(bel.split(".")[0][2:]) + elif bel.startswith("RI"): + s = 5 + elif bel.startswith("S1"): + s = 0 + elif bel.startswith("S2.DSP1"): + s = 7 + else: + return 15 + return s + else: + return 0 + +def split_per_bels(bels): + new_bels = dict() + for k,v in bels.items(): + if k not in split_map: + new_bels[k] = dict() + data = dict(v) + new_bels[k][0] = data + else: + new_bels[k] = dict() + for i in range(4*4): + new_bels[k][i] = dict() + for item,bel in v.items(): + (item, bel) = map_to_beyond(k,item,bel) + if item is not None: + num = determine_subtile(k,item) + new_bels[k][num][item] = bel + return new_bels + +def lookup_port_type(t): + if t == "Input": return PinType.INPUT + elif t == "Output": return PinType.OUTPUT + elif t == "Bidir": return PinType.INOUT + else: assert False + +def create_pips(tt, tile_type, muxes, num, args): + file_path = path.join(args.db, args.device, tile_type + ".txt") + if not path.isfile(file_path): + return + with open(file_path) as f: + for item in f: + line = item.strip().split(" ") + name1,_ = map_to_beyond(tile_type,line[0]) + name2,_ = map_to_beyond(tile_type,line[1]) + if name1 is None or name2 is None: + continue + num1 = determine_subtile(tile_type,name1) + num2 = determine_subtile(tile_type,name2) + + if name2 in muxes: + name2 = name2 + "." + line[2] + if num1==num and not tt.has_wire(name1): + tt.create_wire(name=name1, type=tile_type + "_WIRE") + if num2==num and not tt.has_wire(name2): + tt.create_wire(name=name2, type=tile_type + "_WIRE") + timing_class = line[3] + # Only create PIP if both ends are in same subtile + if num1==num and num2==num: + tt.create_pip(name1,name2,timing_class) + +def create_tile_types(ch: Chip, bels, bel_pins, crossbars, interconnects, muxes, args): + for tile_type,items in bels.items(): + for num in items.keys(): + if len(items)==1: + sub_type = tile_type + else: + sub_type = tile_type + "_"+str(num) + tt = ch.create_tile_type(sub_type) + + def lookup_site_wire(canon_name): + if not tt.has_wire(canon_name): + tt.create_wire(name=canon_name, type="BEL_PIN_WIRE") + return canon_name + + # Create BELs inside tile + for name,bel in bels[tile_type][num].items(): + nb = tt.create_bel(name, bel, z=bel_z(tile_type,name,bel)) + # Create wires for each BEL port + for index in bel_pins[bel].keys(): + pin = bel_pins[bel][index] + tt.add_bel_pin(nb, pin["name"], lookup_site_wire(f"{name}."+pin["name"]), lookup_port_type(pin["direction"])) + if (tile_type.startswith("TILE") and bel=="BEYOND_FE"): + flag = 0 + fe_nxd = int(name[name.index(".")+3:]) + if (((fe_nxd-1) & 127) < 64): + if ((fe_nxd-1)&31) < 16: + if (fe_nxd & 1)==1: + flag |= BEL_EXTRA_FE_SCC + else: + if (fe_nxd & 1)==0: + flag |= BEL_EXTRA_FE_SCC + + if fe_nxd in (65, 80, 81, 96, 225,240,241,256, 321,336,337,352): + flag |= BEL_EXTRA_FE_CSC + nb.extra_data = BelExtraData(flag) + + # LUT drawers, LO already connected to LJ + vi = tt.create_pip(f"{name}.LJ",f"{name}.LK","Virtual") + vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + vi = tt.create_pip(f"{name}.LJ",f"{name}.LD","Virtual") + vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + vi = tt.create_pip(f"{name}.LJ",f"{name}.LX","Virtual") + vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + # DFF drawers, DO already connected to DJ + vi = tt.create_pip(f"{name}.DJ",f"{name}.DP","Virtual") + vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + vi = tt.create_pip(f"{name}.DJ",f"{name}.DC","Virtual") + vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + #vi = tt.create_pip(f"{name}.DJ",f"{name}.DS","Virtual") + #vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + vi = tt.create_pip(f"{name}.DJ",f"{name}.DK","Virtual") + vi.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_VIRTUAL,0,0) + # DFF bypass + by = tt.create_pip(f"{name}.DI",f"{name}.DO","BYPASS") + by.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_BYPASS,0,0) + elif (tile_type.startswith("TILE") and bel=="CY"): + # matrix of each input to each output combination + # crossbar but use mux placeholder for convenience + for inp in ["I1","I2","I3","I4"]: + for out in ["O1","O2","O3","O4"]: + pd = tt.create_pip(f"{name}."+inp,f"{name}."+out,"MATRIX_PIP") + pd.extra_data = PipExtraData(ch.strs.id(f"{name}."+inp),PIP_EXTRA_MUX,int(inp[1:])-1,int(out[1:])-1) + + elif (tile_type.startswith("IOB") and bel=="DFR"): + by = tt.create_pip(f"{name}.I",f"{name}.O","BYPASS") + by.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_BYPASS,0,0) + elif (tile_type.startswith("IOB") and bel=="DDFR"): + by = tt.create_pip(f"{name}.I",f"{name}.O","BYPASS") + by.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_BYPASS,0,0) + elif (tile_type.startswith("CKG") and bel=="WFG"): + by = tt.create_pip(f"{name}.ZI",f"{name}.ZO","BYPASS") + by.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_BYPASS,0,0) + elif (tile_type.startswith("TUBE") and bel=="GCK"): + # 20 clock signals comming to 20 GCK, SI1 is bypass + by = tt.create_pip(f"{name}.SI1",f"{name}.SO","BYPASS") + by.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_BYPASS,0,0) + # there are CMD signals that can be bypassed as well + #by = tt.create_pip(f"{name}.CMD",f"{name}.SO","BYPASS") + #by.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_BYPASS,0,0) + + + # Add LUT permutation + if USE_LUT_PERMUTATION and tile_type=="TILE": + for name,bel in bels[tile_type][num].items(): + if bel=="BEYOND_FE": + for inp in ["PI1","PI2","PI3","PI4"]: + tt.create_wire(name=f"{name}."+inp, type="LUT_PERMUTATION_WIRE") + for out in ["I1","I2","I3","I4"]: + pd = tt.create_pip(f"{name}."+inp,f"{name}."+out,"LUT_PERMUTATION") + pd.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_LUT_PERMUTATION,int(inp[2:])-1,int(out[1:])-1) + + # Create crossbars as multiple PIPs + for name,xb in crossbars[tile_type][num].items(): + inputs = list() + outputs = list() + for index in bel_pins[xb].keys(): + pin = bel_pins[xb][index] + tt.create_wire(name=f"{name}."+pin["name"], type="CROSSBAR_INPUT_WIRE" if pin["direction"] == "Input" else "CROSSBAR_OUTPUT_WIRE") + for index in bel_pins[xb].keys(): + pin = bel_pins[xb][index] + if pin["direction"] == "Input": + inputs.append(pin["name"]) + else: + outputs.append(pin["name"]) + for inp in inputs: + for out in outputs: + pd = tt.create_pip(f"{name}."+inp,f"{name}."+out,"CROSSBAR_"+xb) + pd.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_CROSSBAR,int(inp[1:])-1,int(out[1:])-1) + + # Interconnects are just PIPs with one I and one O + for name,xb in interconnects[tile_type][num].items(): + for index in bel_pins[xb].keys(): + pin = bel_pins[xb][index] + tt.create_wire(name=f"{name}."+pin["name"], type="INTERCONNECT_INPUT" if pin["direction"] == "Input" else "INTERCONNECT_OUTPUT") + inp = f"{name}."+bel_pins[xb]["I"]["name"] + out = f"{name}."+bel_pins[xb]["O"]["name"] + pd = tt.create_pip(inp,out,"INTERCONNECT") + pd.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_INTERCONNECT,0,0) + + # Create MUXes as many to one connections + if tile_type in muxes: + for (name, n) in muxes[tile_type][num].items(): + for i in range(0,n+1): + new_name = name + "." + str(i) + if not tt.has_wire(new_name): + tt.create_wire(name=new_name, type="MUX_WIRE") + pd = tt.create_pip(new_name,name,"MUX_PIP") + pd.extra_data = PipExtraData(ch.strs.id(name),PIP_EXTRA_MUX,i,0) + + m = muxes[tile_type] if tile_type in muxes else dict() + mux = muxes[tile_type][num] if num in m else dict() + create_pips(tt, tile_type, mux, num, args) + +def create_null(ch: Chip): + tt = ch.create_tile_type("NULL") + +def set_timings(ch, pip_timings, bel_timings): + speed = "DEFAULT" + tmg = ch.set_speed_grades([speed]) + for k,v in pip_timings.items(): + tmg.set_pip_class(grade=speed, name=k, delay=TimingValue(v[0])) + tmg.set_node_class(grade=speed, name=k, delay=TimingValue(v[0])) + tmg.set_pip_class(grade=speed, name="INTERCONNECT", delay=TimingValue(0)) + tmg.set_pip_class(grade=speed, name="MUX_PIP", delay=TimingValue(0)) + tmg.set_pip_class(grade=speed, name="MATRIX_PIP", delay=TimingValue(0)) + tmg.set_pip_class(grade=speed, name="LUT_PERMUTATION", delay=TimingValue(0)) + tmg.set_pip_class(grade=speed, name="BYPASS", delay=TimingValue(142)) + for k,g in bel_timings.items(): + primitive = ch.timing.add_cell_variant(speed, k) + for t,v in g.items(): + if t=="IOPath": + for from_port,values in v.items(): + for to_port,data in values.items(): + primitive.add_comb_arc(from_port, to_port, TimingValue(data[0], data[1])) + elif t=="SetupHold": + for from_port,values in v.items(): + for to_port,data in values.items(): + primitive.add_setup_hold(from_port, to_port, ClockEdge.RISING, TimingValue(data[0]), TimingValue(data[1])) + elif t=="ClockOut": + for from_port,values in v.items(): + for to_port,data in values.items(): + primitive.add_clock_out(from_port, to_port, ClockEdge.RISING, TimingValue(data[0],data[1])) + +def get_pos(tilegrid,name,bel): + tile = tilegrid[name][0]["orig"] + num = determine_subtile(tile,bel) + item = tilegrid[name][num] + x = item["x"] + y = item["y"] + return (tile,num,x,y) + + +global_connections = dict() +def load_globals(args): + print("Load global connections...") + with gzip.open(path.join(args.db, args.device, "GLOBAL.txt.gz"),"rt") as f: + for item in f: + line = item.strip().split(" ") + tile_name = line[0].split(":")[0] + if tile_name not in global_connections: + global_connections[tile_name] = dict() + if line[0] not in global_connections[tile_name]: + global_connections[tile_name][line[0]] = list() + global_connections[tile_name][line[0]].append(line) + +def create_nodes(ch, tile_name, tilegrid, muxes, pip_timings): + if tile_name not in global_connections: + return + connections = global_connections[tile_name] + for key,val in connections.items(): + name1 = key.split(":") + t1,_,x1,y1 = get_pos(tilegrid,name1[0],name1[1]) + name1[1],_ = map_to_beyond(t1,name1[1]) + if name1[1] is None: + continue + node = [NodeWire(x1, y1, name1[1])] + timing = None + timing_val = -1 + for v in val: + name2 = v[1].split(":") + name2[1],_ = map_to_beyond(tilegrid[name2[0]][0]["orig"],name2[1]) + t2,num,x2,y2 = get_pos(tilegrid,name2[0],name2[1]) + if name2[1] is None: + continue + if pip_timings[v[3]][0] > timing_val: + timing_val = pip_timings[v[3]][0] + timing = v[3] + if t2 in muxes and num in muxes[t2] and name2[1] in muxes[t2][num]: + node.append(NodeWire(x2, y2, name2[1]+"."+v[2])) + else: + node.append(NodeWire(x2, y2, name2[1])) + + ch.add_node(node,timing_class=timing) + + +subtile_connections = dict() +def create_nodes_subtiles(ch, tilegrid, name, tile_type, muxes, pip_timings, args): + if tile_type not in subtile_connections: + subtile_connections[tile_type] = dict() + + file_path = path.join(args.db, args.device, tile_type + ".txt") + if not path.isfile(file_path): + return + with open(file_path) as f: + for item in f: + line = item.strip().split(" ") + name1 = line[0] + name2 = line[1] + name1,_ = map_to_beyond(tile_type,line[0]) + name2,_ = map_to_beyond(tile_type,line[1]) + if name1 is None or name2 is None: + continue + num1 = determine_subtile(tile_type,name1) + num2 = determine_subtile(tile_type,name2) + # Only create WIRE if ends are NOT in same subtile + if num1!=num2: + if name1 not in subtile_connections[tile_type] : + subtile_connections[tile_type][name1] = list() + subtile_connections[tile_type][name1].append([name1, name2, line[2], line[3]]) + + for name1,val in subtile_connections[tile_type].items(): + _,_,x1,y1 = get_pos(tilegrid,name,name1) + node = [NodeWire(x1, y1, name1)] + timing_val = -1 + timing = None + for v in val: + name2 = v[1] + t2,num,x2,y2 = get_pos(tilegrid,name,name2) + if pip_timings[v[3]][0] > timing_val: + timing_val = pip_timings[v[3]][0] + timing = v[3] + if t2 in muxes and num in muxes[t2] and name2 in muxes[t2][num]: + node.append(NodeWire(x2, y2, name2+"."+v[2])) + else: + node.append(NodeWire(x2, y2, name2)) + + ch.add_node(node,timing_class=timing) + +def import_package(ch, package, bels, tilegrid): + pkg = ch.create_package(package) + for name, data in tilegrid.items(): + for key, item in data.items(): + ty = item["orig"] + x = item["x"] + y = item["y"] + if ty.startswith("IOB"): + for bel,ty in bels[ty][key].items(): + # Support for native primitives + if ty =="IOTP": + pin = name+"_"+bel[:4] + elif ty =="IOP": + pin = name+"_"+bel[:3] + else: + continue + pkg.create_pad(pin, f"X{x}Y{y}", bel, "", int(name[3:])) + +def main(): + xlbase = path.join(path.dirname(path.realpath(__file__)), "..") + + parser = argparse.ArgumentParser() + parser.add_argument("--db", help="Project Beyond device database path (e.g. ../prjbeyond/database)", type=str, required=True) + parser.add_argument("--device", help="name of device to export", type=str, required=True) + parser.add_argument("--constids", help="name of nextpnr constids file to read", type=str, default=path.join(xlbase, "constids.inc")) + parser.add_argument("--bba", help="bba file to write", type=str, required=True) + args = parser.parse_args() + + with open(path.join(args.db, "devices.json")) as f: + devices = json.load(f) + + width = (devices["families"][args.device]["max_col"] + 1) * 4 + height = (devices["families"][args.device]["max_row"] + 1) * 4 + packages = devices["families"][args.device]["packages"] + + ch = Chip("ng-ultra",args.device, width, height) + ch.strs.read_constids(path.join(path.dirname(__file__), "..", "constids.inc")) + + # Data that is depending of location + with open(path.join(args.db, args.device, "tilegrid.json")) as f: + tilegrid = split_tilegrid(json.load(f)) + + with open(path.join(args.db, args.device, "bels.json")) as f: + bels = split_per_bels(json.load(f)) + + with open(path.join(args.db, args.device, "crossbars.json")) as f: + crossbars = split_per_bels(json.load(f)) + + with open(path.join(args.db, args.device, "interconnects.json")) as f: + interconnects = split_per_bels(json.load(f)) + + with open(path.join(args.db, args.device, "muxes.json")) as f: + muxes = split_per_bels(json.load(f)) + + # Data that is not related to position + with open(path.join(args.db, args.device, "bel_pins.json")) as f: + bel_pins = json.load(f) + bel_pins["IOP"]["IO"] = { "direction": "Bidir", "name": "IO" } + bel_pins["IOTP"]["IO"] = { "direction": "Bidir", "name": "IO" } + + with open(path.join(args.db, args.device, "pip_timings.json")) as f: + pip_timings = json.load(f) + + with open(path.join(args.db, args.device, "bel_timings.json")) as f: + bel_timings = json.load(f) + + create_tile_types(ch, bels, bel_pins, crossbars, interconnects, muxes, args) + create_null(ch) + set_timings(ch, pip_timings, bel_timings) + + for x in range(width): + for y in range(height): + ch.set_tile_type(x,y,"NULL") + + load_globals(args) + for name, data in tilegrid.items(): + for item in data.values(): + ti = ch.set_tile_type(item["x"],item["y"],item["type"]) + lobe = 0 + if item["orig"] in ["TILE","CGB"]: + tmp = name.replace("TILE[","").replace("CGB[","").replace("]","") + x,y = tmp.split("x") + lobe = ((int(y)-1) // 12)*2 + (1 if int(x)>46 else 0) + 1 + ti.extra_data = TileExtraData(ch.strs.id(name),lobe) + + for name, data in tilegrid.items(): + print(f"Generate nodes for {name}...") + create_nodes_subtiles(ch, tilegrid, name, data[0]["orig"], muxes, pip_timings, args) + create_nodes(ch, name, tilegrid, muxes, pip_timings) + + for package in packages: + import_package(ch, package, bels, tilegrid) + + ch.write_bba(args.bba) + +if __name__ == '__main__': + main() diff --git a/himbaechel/uarch/ng-ultra/json.hpp b/himbaechel/uarch/ng-ultra/json.hpp new file mode 100644 index 00000000..b191bb91 --- /dev/null +++ b/himbaechel/uarch/ng-ultra/json.hpp @@ -0,0 +1,24766 @@ +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +/****************************************************************************\ + * Note on documentation: The source files contain links to the online * + * documentation of the public API at https://json.nlohmann.me. This URL * + * contains the most recent documentation and should also be applicable to * + * previous versions; documentation for deprecated functions is not * + * removed, but marked deprecated. See "Generate documentation" section in * + * file docs/README.md. * +\****************************************************************************/ + +#ifndef INCLUDE_NLOHMANN_JSON_HPP_ +#define INCLUDE_NLOHMANN_JSON_HPP_ + +#include // all_of, find, for_each +#include // nullptr_t, ptrdiff_t, size_t +#include // hash, less +#include // initializer_list +#ifndef JSON_NO_IO + #include // istream, ostream +#endif // JSON_NO_IO +#include // random_access_iterator_tag +#include // unique_ptr +#include // string, stoi, to_string +#include // declval, forward, move, pair, swap +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// This file contains all macro definitions affecting or depending on the ABI + +#ifndef JSON_SKIP_LIBRARY_VERSION_CHECK + #if defined(NLOHMANN_JSON_VERSION_MAJOR) && defined(NLOHMANN_JSON_VERSION_MINOR) && defined(NLOHMANN_JSON_VERSION_PATCH) + #if NLOHMANN_JSON_VERSION_MAJOR != 3 || NLOHMANN_JSON_VERSION_MINOR != 11 || NLOHMANN_JSON_VERSION_PATCH != 3 + #warning "Already included a different version of the library!" + #endif + #endif +#endif + +#define NLOHMANN_JSON_VERSION_MAJOR 3 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_MINOR 11 // NOLINT(modernize-macro-to-enum) +#define NLOHMANN_JSON_VERSION_PATCH 3 // NOLINT(modernize-macro-to-enum) + +#ifndef JSON_DIAGNOSTICS + #define JSON_DIAGNOSTICS 0 +#endif + +#ifndef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0 +#endif + +#if JSON_DIAGNOSTICS + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag +#else + #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS +#endif + +#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON _ldvcmp +#else + #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION + #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0 +#endif + +// Construct the namespace ABI tags component +#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) json_abi ## a ## b +#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b) \ + NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b) + +#define NLOHMANN_JSON_ABI_TAGS \ + NLOHMANN_JSON_ABI_TAGS_CONCAT( \ + NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS, \ + NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON) + +// Construct the namespace version component +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \ + _v ## major ## _ ## minor ## _ ## patch +#define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(major, minor, patch) \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) + +#if NLOHMANN_JSON_NAMESPACE_NO_VERSION +#define NLOHMANN_JSON_NAMESPACE_VERSION +#else +#define NLOHMANN_JSON_NAMESPACE_VERSION \ + NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT(NLOHMANN_JSON_VERSION_MAJOR, \ + NLOHMANN_JSON_VERSION_MINOR, \ + NLOHMANN_JSON_VERSION_PATCH) +#endif + +// Combine namespace components +#define NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) a ## b +#define NLOHMANN_JSON_NAMESPACE_CONCAT(a, b) \ + NLOHMANN_JSON_NAMESPACE_CONCAT_EX(a, b) + +#ifndef NLOHMANN_JSON_NAMESPACE +#define NLOHMANN_JSON_NAMESPACE \ + nlohmann::NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_BEGIN +#define NLOHMANN_JSON_NAMESPACE_BEGIN \ + namespace nlohmann \ + { \ + inline namespace NLOHMANN_JSON_NAMESPACE_CONCAT( \ + NLOHMANN_JSON_ABI_TAGS, \ + NLOHMANN_JSON_NAMESPACE_VERSION) \ + { +#endif + +#ifndef NLOHMANN_JSON_NAMESPACE_END +#define NLOHMANN_JSON_NAMESPACE_END \ + } /* namespace (inline namespace) NOLINT(readability/namespace) */ \ + } // namespace nlohmann +#endif + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // transform +#include // array +#include // forward_list +#include // inserter, front_inserter, end +#include // map +#include // string +#include // tuple, make_tuple +#include // is_arithmetic, is_same, is_enum, underlying_type, is_convertible +#include // unordered_map +#include // pair, declval +#include // valarray + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // nullptr_t +#include // exception +#if JSON_DIAGNOSTICS + #include // accumulate +#endif +#include // runtime_error +#include // to_string +#include // vector + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // uint8_t +#include // string + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // declval, pair +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template struct make_void +{ + using type = void; +}; +template using void_t = typename make_void::type; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +// https://en.cppreference.com/w/cpp/experimental/is_detected +struct nonesuch +{ + nonesuch() = delete; + ~nonesuch() = delete; + nonesuch(nonesuch const&) = delete; + nonesuch(nonesuch const&&) = delete; + void operator=(nonesuch const&) = delete; + void operator=(nonesuch&&) = delete; +}; + +template class Op, + class... Args> +struct detector +{ + using value_t = std::false_type; + using type = Default; +}; + +template class Op, class... Args> +struct detector>, Op, Args...> +{ + using value_t = std::true_type; + using type = Op; +}; + +template class Op, class... Args> +using is_detected = typename detector::value_t; + +template class Op, class... Args> +struct is_detected_lazy : is_detected { }; + +template class Op, class... Args> +using detected_t = typename detector::type; + +template class Op, class... Args> +using detected_or = detector; + +template class Op, class... Args> +using detected_or_t = typename detected_or::type; + +template class Op, class... Args> +using is_detected_exact = std::is_same>; + +template class Op, class... Args> +using is_detected_convertible = + std::is_convertible, To>; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + + +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2016-2021 Evan Nemerson +// SPDX-License-Identifier: MIT + +/* Hedley - https://nemequ.github.io/hedley + * Created by Evan Nemerson + */ + +#if !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < 15) +#if defined(JSON_HEDLEY_VERSION) + #undef JSON_HEDLEY_VERSION +#endif +#define JSON_HEDLEY_VERSION 15 + +#if defined(JSON_HEDLEY_STRINGIFY_EX) + #undef JSON_HEDLEY_STRINGIFY_EX +#endif +#define JSON_HEDLEY_STRINGIFY_EX(x) #x + +#if defined(JSON_HEDLEY_STRINGIFY) + #undef JSON_HEDLEY_STRINGIFY +#endif +#define JSON_HEDLEY_STRINGIFY(x) JSON_HEDLEY_STRINGIFY_EX(x) + +#if defined(JSON_HEDLEY_CONCAT_EX) + #undef JSON_HEDLEY_CONCAT_EX +#endif +#define JSON_HEDLEY_CONCAT_EX(a,b) a##b + +#if defined(JSON_HEDLEY_CONCAT) + #undef JSON_HEDLEY_CONCAT +#endif +#define JSON_HEDLEY_CONCAT(a,b) JSON_HEDLEY_CONCAT_EX(a,b) + +#if defined(JSON_HEDLEY_CONCAT3_EX) + #undef JSON_HEDLEY_CONCAT3_EX +#endif +#define JSON_HEDLEY_CONCAT3_EX(a,b,c) a##b##c + +#if defined(JSON_HEDLEY_CONCAT3) + #undef JSON_HEDLEY_CONCAT3 +#endif +#define JSON_HEDLEY_CONCAT3(a,b,c) JSON_HEDLEY_CONCAT3_EX(a,b,c) + +#if defined(JSON_HEDLEY_VERSION_ENCODE) + #undef JSON_HEDLEY_VERSION_ENCODE +#endif +#define JSON_HEDLEY_VERSION_ENCODE(major,minor,revision) (((major) * 1000000) + ((minor) * 1000) + (revision)) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MAJOR) + #undef JSON_HEDLEY_VERSION_DECODE_MAJOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MAJOR(version) ((version) / 1000000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_MINOR) + #undef JSON_HEDLEY_VERSION_DECODE_MINOR +#endif +#define JSON_HEDLEY_VERSION_DECODE_MINOR(version) (((version) % 1000000) / 1000) + +#if defined(JSON_HEDLEY_VERSION_DECODE_REVISION) + #undef JSON_HEDLEY_VERSION_DECODE_REVISION +#endif +#define JSON_HEDLEY_VERSION_DECODE_REVISION(version) ((version) % 1000) + +#if defined(JSON_HEDLEY_GNUC_VERSION) + #undef JSON_HEDLEY_GNUC_VERSION +#endif +#if defined(__GNUC__) && defined(__GNUC_PATCHLEVEL__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__) +#elif defined(__GNUC__) + #define JSON_HEDLEY_GNUC_VERSION JSON_HEDLEY_VERSION_ENCODE(__GNUC__, __GNUC_MINOR__, 0) +#endif + +#if defined(JSON_HEDLEY_GNUC_VERSION_CHECK) + #undef JSON_HEDLEY_GNUC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GNUC_VERSION) + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GNUC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION) + #undef JSON_HEDLEY_MSVC_VERSION +#endif +#if defined(_MSC_FULL_VER) && (_MSC_FULL_VER >= 140000000) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 10000000, (_MSC_FULL_VER % 10000000) / 100000, (_MSC_FULL_VER % 100000) / 100) +#elif defined(_MSC_FULL_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_FULL_VER / 1000000, (_MSC_FULL_VER % 1000000) / 10000, (_MSC_FULL_VER % 10000) / 10) +#elif defined(_MSC_VER) && !defined(__ICL) + #define JSON_HEDLEY_MSVC_VERSION JSON_HEDLEY_VERSION_ENCODE(_MSC_VER / 100, _MSC_VER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_MSVC_VERSION_CHECK) + #undef JSON_HEDLEY_MSVC_VERSION_CHECK +#endif +#if !defined(JSON_HEDLEY_MSVC_VERSION) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (0) +#elif defined(_MSC_VER) && (_MSC_VER >= 1400) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 10000000) + (minor * 100000) + (patch))) +#elif defined(_MSC_VER) && (_MSC_VER >= 1200) + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_FULL_VER >= ((major * 1000000) + (minor * 10000) + (patch))) +#else + #define JSON_HEDLEY_MSVC_VERSION_CHECK(major,minor,patch) (_MSC_VER >= ((major * 100) + (minor))) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION) + #undef JSON_HEDLEY_INTEL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, __INTEL_COMPILER_UPDATE) +#elif defined(__INTEL_COMPILER) && !defined(__ICL) + #define JSON_HEDLEY_INTEL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER / 100, __INTEL_COMPILER % 100, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_VERSION) + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #undef JSON_HEDLEY_INTEL_CL_VERSION +#endif +#if defined(__INTEL_COMPILER) && defined(__INTEL_COMPILER_UPDATE) && defined(__ICL) + #define JSON_HEDLEY_INTEL_CL_VERSION JSON_HEDLEY_VERSION_ENCODE(__INTEL_COMPILER, __INTEL_COMPILER_UPDATE, 0) +#endif + +#if defined(JSON_HEDLEY_INTEL_CL_VERSION_CHECK) + #undef JSON_HEDLEY_INTEL_CL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_INTEL_CL_VERSION) + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_INTEL_CL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_INTEL_CL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION) + #undef JSON_HEDLEY_PGI_VERSION +#endif +#if defined(__PGI) && defined(__PGIC__) && defined(__PGIC_MINOR__) && defined(__PGIC_PATCHLEVEL__) + #define JSON_HEDLEY_PGI_VERSION JSON_HEDLEY_VERSION_ENCODE(__PGIC__, __PGIC_MINOR__, __PGIC_PATCHLEVEL__) +#endif + +#if defined(JSON_HEDLEY_PGI_VERSION_CHECK) + #undef JSON_HEDLEY_PGI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PGI_VERSION) + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PGI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PGI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #undef JSON_HEDLEY_SUNPRO_VERSION +#endif +#if defined(__SUNPRO_C) && (__SUNPRO_C > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_C >> 16) & 0xf) * 10) + ((__SUNPRO_C >> 12) & 0xf), (((__SUNPRO_C >> 8) & 0xf) * 10) + ((__SUNPRO_C >> 4) & 0xf), (__SUNPRO_C & 0xf) * 10) +#elif defined(__SUNPRO_C) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_C >> 8) & 0xf, (__SUNPRO_C >> 4) & 0xf, (__SUNPRO_C) & 0xf) +#elif defined(__SUNPRO_CC) && (__SUNPRO_CC > 0x1000) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((((__SUNPRO_CC >> 16) & 0xf) * 10) + ((__SUNPRO_CC >> 12) & 0xf), (((__SUNPRO_CC >> 8) & 0xf) * 10) + ((__SUNPRO_CC >> 4) & 0xf), (__SUNPRO_CC & 0xf) * 10) +#elif defined(__SUNPRO_CC) + #define JSON_HEDLEY_SUNPRO_VERSION JSON_HEDLEY_VERSION_ENCODE((__SUNPRO_CC >> 8) & 0xf, (__SUNPRO_CC >> 4) & 0xf, (__SUNPRO_CC) & 0xf) +#endif + +#if defined(JSON_HEDLEY_SUNPRO_VERSION_CHECK) + #undef JSON_HEDLEY_SUNPRO_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_SUNPRO_VERSION) + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_SUNPRO_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_SUNPRO_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION +#endif +#if defined(__EMSCRIPTEN__) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION JSON_HEDLEY_VERSION_ENCODE(__EMSCRIPTEN_major__, __EMSCRIPTEN_minor__, __EMSCRIPTEN_tiny__) +#endif + +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK) + #undef JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_EMSCRIPTEN_VERSION) + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_EMSCRIPTEN_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_EMSCRIPTEN_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION) + #undef JSON_HEDLEY_ARM_VERSION +#endif +#if defined(__CC_ARM) && defined(__ARMCOMPILER_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCOMPILER_VERSION / 1000000, (__ARMCOMPILER_VERSION % 1000000) / 10000, (__ARMCOMPILER_VERSION % 10000) / 100) +#elif defined(__CC_ARM) && defined(__ARMCC_VERSION) + #define JSON_HEDLEY_ARM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ARMCC_VERSION / 1000000, (__ARMCC_VERSION % 1000000) / 10000, (__ARMCC_VERSION % 10000) / 100) +#endif + +#if defined(JSON_HEDLEY_ARM_VERSION_CHECK) + #undef JSON_HEDLEY_ARM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_ARM_VERSION) + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_ARM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_ARM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION) + #undef JSON_HEDLEY_IBM_VERSION +#endif +#if defined(__ibmxl__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__ibmxl_version__, __ibmxl_release__, __ibmxl_modification__) +#elif defined(__xlC__) && defined(__xlC_ver__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, (__xlC_ver__ >> 8) & 0xff) +#elif defined(__xlC__) + #define JSON_HEDLEY_IBM_VERSION JSON_HEDLEY_VERSION_ENCODE(__xlC__ >> 8, __xlC__ & 0xff, 0) +#endif + +#if defined(JSON_HEDLEY_IBM_VERSION_CHECK) + #undef JSON_HEDLEY_IBM_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IBM_VERSION) + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IBM_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IBM_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_VERSION) + #undef JSON_HEDLEY_TI_VERSION +#endif +#if \ + defined(__TI_COMPILER_VERSION__) && \ + ( \ + defined(__TMS470__) || defined(__TI_ARM__) || \ + defined(__MSP430__) || \ + defined(__TMS320C2000__) \ + ) +#if (__TI_COMPILER_VERSION__ >= 16000000) + #define JSON_HEDLEY_TI_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif +#endif + +#if defined(JSON_HEDLEY_TI_VERSION_CHECK) + #undef JSON_HEDLEY_TI_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_VERSION) + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #undef JSON_HEDLEY_TI_CL2000_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C2000__) + #define JSON_HEDLEY_TI_CL2000_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL2000_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL2000_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL2000_VERSION) + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL2000_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL2000_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #undef JSON_HEDLEY_TI_CL430_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__MSP430__) + #define JSON_HEDLEY_TI_CL430_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL430_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL430_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL430_VERSION) + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL430_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL430_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #undef JSON_HEDLEY_TI_ARMCL_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && (defined(__TMS470__) || defined(__TI_ARM__)) + #define JSON_HEDLEY_TI_ARMCL_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION_CHECK) + #undef JSON_HEDLEY_TI_ARMCL_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_ARMCL_VERSION) + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_ARMCL_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #undef JSON_HEDLEY_TI_CL6X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__TMS320C6X__) + #define JSON_HEDLEY_TI_CL6X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL6X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL6X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL6X_VERSION) + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL6X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL6X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #undef JSON_HEDLEY_TI_CL7X_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__C7000__) + #define JSON_HEDLEY_TI_CL7X_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CL7X_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CL7X_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CL7X_VERSION) + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CL7X_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CL7X_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #undef JSON_HEDLEY_TI_CLPRU_VERSION +#endif +#if defined(__TI_COMPILER_VERSION__) && defined(__PRU__) + #define JSON_HEDLEY_TI_CLPRU_VERSION JSON_HEDLEY_VERSION_ENCODE(__TI_COMPILER_VERSION__ / 1000000, (__TI_COMPILER_VERSION__ % 1000000) / 1000, (__TI_COMPILER_VERSION__ % 1000)) +#endif + +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION_CHECK) + #undef JSON_HEDLEY_TI_CLPRU_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TI_CLPRU_VERSION) + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TI_CLPRU_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION) + #undef JSON_HEDLEY_CRAY_VERSION +#endif +#if defined(_CRAYC) + #if defined(_RELEASE_PATCHLEVEL) + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, _RELEASE_PATCHLEVEL) + #else + #define JSON_HEDLEY_CRAY_VERSION JSON_HEDLEY_VERSION_ENCODE(_RELEASE_MAJOR, _RELEASE_MINOR, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_CRAY_VERSION_CHECK) + #undef JSON_HEDLEY_CRAY_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_CRAY_VERSION) + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_CRAY_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_CRAY_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION) + #undef JSON_HEDLEY_IAR_VERSION +#endif +#if defined(__IAR_SYSTEMS_ICC__) + #if __VER__ > 1000 + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE((__VER__ / 1000000), ((__VER__ / 1000) % 1000), (__VER__ % 1000)) + #else + #define JSON_HEDLEY_IAR_VERSION JSON_HEDLEY_VERSION_ENCODE(__VER__ / 100, __VER__ % 100, 0) + #endif +#endif + +#if defined(JSON_HEDLEY_IAR_VERSION_CHECK) + #undef JSON_HEDLEY_IAR_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_IAR_VERSION) + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_IAR_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_IAR_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION) + #undef JSON_HEDLEY_TINYC_VERSION +#endif +#if defined(__TINYC__) + #define JSON_HEDLEY_TINYC_VERSION JSON_HEDLEY_VERSION_ENCODE(__TINYC__ / 1000, (__TINYC__ / 100) % 10, __TINYC__ % 100) +#endif + +#if defined(JSON_HEDLEY_TINYC_VERSION_CHECK) + #undef JSON_HEDLEY_TINYC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_TINYC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_TINYC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION) + #undef JSON_HEDLEY_DMC_VERSION +#endif +#if defined(__DMC__) + #define JSON_HEDLEY_DMC_VERSION JSON_HEDLEY_VERSION_ENCODE(__DMC__ >> 8, (__DMC__ >> 4) & 0xf, __DMC__ & 0xf) +#endif + +#if defined(JSON_HEDLEY_DMC_VERSION_CHECK) + #undef JSON_HEDLEY_DMC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_DMC_VERSION) + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_DMC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_DMC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #undef JSON_HEDLEY_COMPCERT_VERSION +#endif +#if defined(__COMPCERT_VERSION__) + #define JSON_HEDLEY_COMPCERT_VERSION JSON_HEDLEY_VERSION_ENCODE(__COMPCERT_VERSION__ / 10000, (__COMPCERT_VERSION__ / 100) % 100, __COMPCERT_VERSION__ % 100) +#endif + +#if defined(JSON_HEDLEY_COMPCERT_VERSION_CHECK) + #undef JSON_HEDLEY_COMPCERT_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_COMPCERT_VERSION) + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_COMPCERT_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_COMPCERT_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION) + #undef JSON_HEDLEY_PELLES_VERSION +#endif +#if defined(__POCC__) + #define JSON_HEDLEY_PELLES_VERSION JSON_HEDLEY_VERSION_ENCODE(__POCC__ / 100, __POCC__ % 100, 0) +#endif + +#if defined(JSON_HEDLEY_PELLES_VERSION_CHECK) + #undef JSON_HEDLEY_PELLES_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_PELLES_VERSION) + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_PELLES_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_PELLES_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #undef JSON_HEDLEY_MCST_LCC_VERSION +#endif +#if defined(__LCC__) && defined(__LCC_MINOR__) + #define JSON_HEDLEY_MCST_LCC_VERSION JSON_HEDLEY_VERSION_ENCODE(__LCC__ / 100, __LCC__ % 100, __LCC_MINOR__) +#endif + +#if defined(JSON_HEDLEY_MCST_LCC_VERSION_CHECK) + #undef JSON_HEDLEY_MCST_LCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_MCST_LCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_MCST_LCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION) + #undef JSON_HEDLEY_GCC_VERSION +#endif +#if \ + defined(JSON_HEDLEY_GNUC_VERSION) && \ + !defined(__clang__) && \ + !defined(JSON_HEDLEY_INTEL_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_ARM_VERSION) && \ + !defined(JSON_HEDLEY_CRAY_VERSION) && \ + !defined(JSON_HEDLEY_TI_VERSION) && \ + !defined(JSON_HEDLEY_TI_ARMCL_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL430_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL2000_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL6X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CL7X_VERSION) && \ + !defined(JSON_HEDLEY_TI_CLPRU_VERSION) && \ + !defined(__COMPCERT__) && \ + !defined(JSON_HEDLEY_MCST_LCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION JSON_HEDLEY_GNUC_VERSION +#endif + +#if defined(JSON_HEDLEY_GCC_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_VERSION_CHECK +#endif +#if defined(JSON_HEDLEY_GCC_VERSION) + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (JSON_HEDLEY_GCC_VERSION >= JSON_HEDLEY_VERSION_ENCODE(major, minor, patch)) +#else + #define JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_ATTRIBUTE +#endif +#if \ + defined(__has_attribute) && \ + ( \ + (!defined(JSON_HEDLEY_IAR_VERSION) || JSON_HEDLEY_IAR_VERSION_CHECK(8,5,9)) \ + ) +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) __has_attribute(attribute) +#else +# define JSON_HEDLEY_HAS_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_ATTRIBUTE +#endif +#if defined(__has_attribute) + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE +#endif +#if \ + defined(__has_cpp_attribute) && \ + defined(__cplusplus) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS) + #undef JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS +#endif +#if !defined(__cplusplus) || !defined(__has_cpp_attribute) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#elif \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION) && \ + (!defined(JSON_HEDLEY_SUNPRO_VERSION) || JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0)) && \ + (!defined(JSON_HEDLEY_MSVC_VERSION) || JSON_HEDLEY_MSVC_VERSION_CHECK(19,20,0)) + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(ns::attribute) +#else + #define JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(ns,attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE +#endif +#if defined(__has_cpp_attribute) && defined(__cplusplus) + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) __has_cpp_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_CPP_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_BUILTIN) + #undef JSON_HEDLEY_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_HAS_BUILTIN(builtin) __has_builtin(builtin) +#else + #define JSON_HEDLEY_HAS_BUILTIN(builtin) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_BUILTIN) + #undef JSON_HEDLEY_GNUC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GNUC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_BUILTIN) + #undef JSON_HEDLEY_GCC_HAS_BUILTIN +#endif +#if defined(__has_builtin) + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) __has_builtin(builtin) +#else + #define JSON_HEDLEY_GCC_HAS_BUILTIN(builtin,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_FEATURE) + #undef JSON_HEDLEY_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_HAS_FEATURE(feature) __has_feature(feature) +#else + #define JSON_HEDLEY_HAS_FEATURE(feature) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_FEATURE) + #undef JSON_HEDLEY_GNUC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GNUC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_FEATURE) + #undef JSON_HEDLEY_GCC_HAS_FEATURE +#endif +#if defined(__has_feature) + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) __has_feature(feature) +#else + #define JSON_HEDLEY_GCC_HAS_FEATURE(feature,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_EXTENSION) + #undef JSON_HEDLEY_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_HAS_EXTENSION(extension) __has_extension(extension) +#else + #define JSON_HEDLEY_HAS_EXTENSION(extension) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_EXTENSION) + #undef JSON_HEDLEY_GNUC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GNUC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_EXTENSION) + #undef JSON_HEDLEY_GCC_HAS_EXTENSION +#endif +#if defined(__has_extension) + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) __has_extension(extension) +#else + #define JSON_HEDLEY_GCC_HAS_EXTENSION(extension,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GNUC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE +#endif +#if defined(__has_declspec_attribute) + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) __has_declspec_attribute(attribute) +#else + #define JSON_HEDLEY_GCC_HAS_DECLSPEC_ATTRIBUTE(attribute,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_HAS_WARNING) + #undef JSON_HEDLEY_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_HAS_WARNING(warning) __has_warning(warning) +#else + #define JSON_HEDLEY_HAS_WARNING(warning) (0) +#endif + +#if defined(JSON_HEDLEY_GNUC_HAS_WARNING) + #undef JSON_HEDLEY_GNUC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GNUC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GNUC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_GCC_HAS_WARNING) + #undef JSON_HEDLEY_GCC_HAS_WARNING +#endif +#if defined(__has_warning) + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) __has_warning(warning) +#else + #define JSON_HEDLEY_GCC_HAS_WARNING(warning,major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + defined(__clang__) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,17) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(8,0,0) || \ + (JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) && defined(__C99_PRAGMA_OPERATOR)) + #define JSON_HEDLEY_PRAGMA(value) _Pragma(#value) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_PRAGMA(value) __pragma(value) +#else + #define JSON_HEDLEY_PRAGMA(value) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_PUSH) + #undef JSON_HEDLEY_DIAGNOSTIC_PUSH +#endif +#if defined(JSON_HEDLEY_DIAGNOSTIC_POP) + #undef JSON_HEDLEY_DIAGNOSTIC_POP +#endif +#if defined(__clang__) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("clang diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("clang diagnostic pop") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("GCC diagnostic push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("GCC diagnostic pop") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH __pragma(warning(push)) + #define JSON_HEDLEY_DIAGNOSTIC_POP __pragma(warning(pop)) +#elif JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("pop") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("diag_push") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("diag_pop") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_PUSH _Pragma("warning(push)") + #define JSON_HEDLEY_DIAGNOSTIC_POP _Pragma("warning(pop)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_PUSH + #define JSON_HEDLEY_DIAGNOSTIC_POP +#endif + +/* JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_ +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat") +# if JSON_HEDLEY_HAS_WARNING("-Wc++17-extensions") +# if JSON_HEDLEY_HAS_WARNING("-Wc++1z-extensions") +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + _Pragma("clang diagnostic ignored \"-Wc++1z-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + _Pragma("clang diagnostic ignored \"-Wc++17-extensions\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# else +# define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(xpr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wc++98-compat\"") \ + xpr \ + JSON_HEDLEY_DIAGNOSTIC_POP +# endif +# endif +#endif +#if !defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(x) x +#endif + +#if defined(JSON_HEDLEY_CONST_CAST) + #undef JSON_HEDLEY_CONST_CAST +#endif +#if defined(__cplusplus) +# define JSON_HEDLEY_CONST_CAST(T, expr) (const_cast(expr)) +#elif \ + JSON_HEDLEY_HAS_WARNING("-Wcast-qual") || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_CONST_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_CONST_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_REINTERPRET_CAST) + #undef JSON_HEDLEY_REINTERPRET_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) (reinterpret_cast(expr)) +#else + #define JSON_HEDLEY_REINTERPRET_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_STATIC_CAST) + #undef JSON_HEDLEY_STATIC_CAST +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_STATIC_CAST(T, expr) (static_cast(expr)) +#else + #define JSON_HEDLEY_STATIC_CAST(T, expr) ((T) (expr)) +#endif + +#if defined(JSON_HEDLEY_CPP_CAST) + #undef JSON_HEDLEY_CPP_CAST +#endif +#if defined(__cplusplus) +# if JSON_HEDLEY_HAS_WARNING("-Wold-style-cast") +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wold-style-cast\"") \ + ((T) (expr)) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# elif JSON_HEDLEY_IAR_VERSION_CHECK(8,3,0) +# define JSON_HEDLEY_CPP_CAST(T, expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("diag_suppress=Pe137") \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_CPP_CAST(T, expr) ((T) (expr)) +# endif +#else +# define JSON_HEDLEY_CPP_CAST(T, expr) (expr) +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wdeprecated-declarations") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warning(disable:1478 1786)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:1478 1786)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1216,1444,1445") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED __pragma(warning(disable:4996)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1215,1444") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress 1291,1718") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && !defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,E_DEPRECATED_ATT,E_DEPRECATED_ATT_MESS)") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("error_messages(off,symdeprecated,symdeprecated2)") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("diag_suppress=Pe1444,Pe1215") +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,90,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED _Pragma("warn(disable:2241)") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_DEPRECATED +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("clang diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("warning(disable:161)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:161)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 1675") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("GCC diagnostic ignored \"-Wunknown-pragmas\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS __pragma(warning(disable:4068)) +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(16,9,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 163") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress=Pe161") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS _Pragma("diag_suppress 161") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-attributes") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("clang diagnostic ignored \"-Wunknown-attributes\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(4,6,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("warning(disable:1292)") +#elif JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:1292)) +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES __pragma(warning(disable:5030)) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(20,7,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097,1098") +#elif JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("error_messages(off,attrskipunsup)") +#elif \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1173") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress=Pe1097") +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES _Pragma("diag_suppress 1097") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_CPP_ATTRIBUTES +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wcast-qual") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("clang diagnostic ignored \"-Wcast-qual\"") +#elif JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("warning(disable:2203 2331)") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL _Pragma("GCC diagnostic ignored \"-Wcast-qual\"") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_CAST_QUAL +#endif + +#if defined(JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION) + #undef JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunused-function") + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("clang diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("GCC diagnostic ignored \"-Wunused-function\"") +#elif JSON_HEDLEY_MSVC_VERSION_CHECK(1,0,0) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION __pragma(warning(disable:4505)) +#elif JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION _Pragma("diag_suppress 3142") +#else + #define JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNUSED_FUNCTION +#endif + +#if defined(JSON_HEDLEY_DEPRECATED) + #undef JSON_HEDLEY_DEPRECATED +#endif +#if defined(JSON_HEDLEY_DEPRECATED_FOR) + #undef JSON_HEDLEY_DEPRECATED_FOR +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated("Since " # since)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated("Since " #since "; use " #replacement)) +#elif \ + (JSON_HEDLEY_HAS_EXTENSION(attribute_deprecated_with_message) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,13,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(18,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,3,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,3,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__("Since " #since))) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__("Since " #since "; use " #replacement))) +#elif defined(__cplusplus) && (__cplusplus >= 201402L) + #define JSON_HEDLEY_DEPRECATED(since) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since)]]) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[deprecated("Since " #since "; use " #replacement)]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(deprecated) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_DEPRECATED(since) __attribute__((__deprecated__)) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __attribute__((__deprecated__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_PELLES_VERSION_CHECK(6,50,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_DEPRECATED(since) __declspec(deprecated) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) __declspec(deprecated) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_DEPRECATED(since) _Pragma("deprecated") + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) _Pragma("deprecated") +#else + #define JSON_HEDLEY_DEPRECATED(since) + #define JSON_HEDLEY_DEPRECATED_FOR(since, replacement) +#endif + +#if defined(JSON_HEDLEY_UNAVAILABLE) + #undef JSON_HEDLEY_UNAVAILABLE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warning) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNAVAILABLE(available_since) __attribute__((__warning__("Not available until " #available_since))) +#else + #define JSON_HEDLEY_UNAVAILABLE(available_since) +#endif + +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT +#endif +#if defined(JSON_HEDLEY_WARN_UNUSED_RESULT_MSG) + #undef JSON_HEDLEY_WARN_UNUSED_RESULT_MSG +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(warn_unused_result) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) __attribute__((__warn_unused_result__)) +#elif (JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) >= 201907L) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard(msg)]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(nodiscard) + #define JSON_HEDLEY_WARN_UNUSED_RESULT JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[nodiscard]]) +#elif defined(_Check_return_) /* SAL */ + #define JSON_HEDLEY_WARN_UNUSED_RESULT _Check_return_ + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) _Check_return_ +#else + #define JSON_HEDLEY_WARN_UNUSED_RESULT + #define JSON_HEDLEY_WARN_UNUSED_RESULT_MSG(msg) +#endif + +#if defined(JSON_HEDLEY_SENTINEL) + #undef JSON_HEDLEY_SENTINEL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(sentinel) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_SENTINEL(position) __attribute__((__sentinel__(position))) +#else + #define JSON_HEDLEY_SENTINEL(position) +#endif + +#if defined(JSON_HEDLEY_NO_RETURN) + #undef JSON_HEDLEY_NO_RETURN +#endif +#if JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NO_RETURN __noreturn +#elif \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L + #define JSON_HEDLEY_NO_RETURN _Noreturn +#elif defined(__cplusplus) && (__cplusplus >= 201103L) + #define JSON_HEDLEY_NO_RETURN JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[noreturn]]) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(noreturn) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,2,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NO_RETURN __attribute__((__noreturn__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_NO_RETURN _Pragma("does_not_return") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NO_RETURN _Pragma("FUNC_NEVER_RETURNS;") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NO_RETURN __attribute((noreturn)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NO_RETURN __declspec(noreturn) +#else + #define JSON_HEDLEY_NO_RETURN +#endif + +#if defined(JSON_HEDLEY_NO_ESCAPE) + #undef JSON_HEDLEY_NO_ESCAPE +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(noescape) + #define JSON_HEDLEY_NO_ESCAPE __attribute__((__noescape__)) +#else + #define JSON_HEDLEY_NO_ESCAPE +#endif + +#if defined(JSON_HEDLEY_UNREACHABLE) + #undef JSON_HEDLEY_UNREACHABLE +#endif +#if defined(JSON_HEDLEY_UNREACHABLE_RETURN) + #undef JSON_HEDLEY_UNREACHABLE_RETURN +#endif +#if defined(JSON_HEDLEY_ASSUME) + #undef JSON_HEDLEY_ASSUME +#endif +#if \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_ASSUME(expr) __assume(expr) +#elif JSON_HEDLEY_HAS_BUILTIN(__builtin_assume) + #define JSON_HEDLEY_ASSUME(expr) __builtin_assume(expr) +#elif \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #if defined(__cplusplus) + #define JSON_HEDLEY_ASSUME(expr) std::_nassert(expr) + #else + #define JSON_HEDLEY_ASSUME(expr) _nassert(expr) + #endif +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_unreachable) && (!defined(JSON_HEDLEY_ARM_VERSION))) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,5,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,10,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,5) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(10,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_UNREACHABLE() __builtin_unreachable() +#elif defined(JSON_HEDLEY_ASSUME) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif +#if !defined(JSON_HEDLEY_ASSUME) + #if defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, ((expr) ? 1 : (JSON_HEDLEY_UNREACHABLE(), 1))) + #else + #define JSON_HEDLEY_ASSUME(expr) JSON_HEDLEY_STATIC_CAST(void, expr) + #endif +#endif +#if defined(JSON_HEDLEY_UNREACHABLE) + #if \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (JSON_HEDLEY_STATIC_CAST(void, JSON_HEDLEY_ASSUME(0)), (value)) + #else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) JSON_HEDLEY_UNREACHABLE() + #endif +#else + #define JSON_HEDLEY_UNREACHABLE_RETURN(value) return (value) +#endif +#if !defined(JSON_HEDLEY_UNREACHABLE) + #define JSON_HEDLEY_UNREACHABLE() JSON_HEDLEY_ASSUME(0) +#endif + +JSON_HEDLEY_DIAGNOSTIC_PUSH +#if JSON_HEDLEY_HAS_WARNING("-Wpedantic") + #pragma clang diagnostic ignored "-Wpedantic" +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wc++98-compat-pedantic") && defined(__cplusplus) + #pragma clang diagnostic ignored "-Wc++98-compat-pedantic" +#endif +#if JSON_HEDLEY_GCC_HAS_WARNING("-Wvariadic-macros",4,0,0) + #if defined(__clang__) + #pragma clang diagnostic ignored "-Wvariadic-macros" + #elif defined(JSON_HEDLEY_GCC_VERSION) + #pragma GCC diagnostic ignored "-Wvariadic-macros" + #endif +#endif +#if defined(JSON_HEDLEY_NON_NULL) + #undef JSON_HEDLEY_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NON_NULL(...) __attribute__((__nonnull__(__VA_ARGS__))) +#else + #define JSON_HEDLEY_NON_NULL(...) +#endif +JSON_HEDLEY_DIAGNOSTIC_POP + +#if defined(JSON_HEDLEY_PRINTF_FORMAT) + #undef JSON_HEDLEY_PRINTF_FORMAT +#endif +#if defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && !defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(ms_printf, string_idx, first_to_check))) +#elif defined(__MINGW32__) && JSON_HEDLEY_GCC_HAS_ATTRIBUTE(format,4,4,0) && defined(__USE_MINGW_ANSI_STDIO) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(gnu_printf, string_idx, first_to_check))) +#elif \ + JSON_HEDLEY_HAS_ATTRIBUTE(format) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,6,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __attribute__((__format__(__printf__, string_idx, first_to_check))) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(6,0,0) + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) __declspec(vaformat(printf,string_idx,first_to_check)) +#else + #define JSON_HEDLEY_PRINTF_FORMAT(string_idx,first_to_check) +#endif + +#if defined(JSON_HEDLEY_CONSTEXPR) + #undef JSON_HEDLEY_CONSTEXPR +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_CONSTEXPR JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(constexpr) + #endif +#endif +#if !defined(JSON_HEDLEY_CONSTEXPR) + #define JSON_HEDLEY_CONSTEXPR +#endif + +#if defined(JSON_HEDLEY_PREDICT) + #undef JSON_HEDLEY_PREDICT +#endif +#if defined(JSON_HEDLEY_LIKELY) + #undef JSON_HEDLEY_LIKELY +#endif +#if defined(JSON_HEDLEY_UNLIKELY) + #undef JSON_HEDLEY_UNLIKELY +#endif +#if defined(JSON_HEDLEY_UNPREDICTABLE) + #undef JSON_HEDLEY_UNPREDICTABLE +#endif +#if JSON_HEDLEY_HAS_BUILTIN(__builtin_unpredictable) + #define JSON_HEDLEY_UNPREDICTABLE(expr) __builtin_unpredictable((expr)) +#endif +#if \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect_with_probability) && !defined(JSON_HEDLEY_PGI_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(9,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, value, probability) __builtin_expect_with_probability( (expr), (value), (probability)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) __builtin_expect_with_probability(!!(expr), 1 , (probability)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) __builtin_expect_with_probability(!!(expr), 0 , (probability)) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect (!!(expr), 1 ) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect (!!(expr), 0 ) +#elif \ + (JSON_HEDLEY_HAS_BUILTIN(__builtin_expect) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,15,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,7,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,27) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PREDICT(expr, expected, probability) \ + (((probability) >= 0.9) ? __builtin_expect((expr), (expected)) : (JSON_HEDLEY_STATIC_CAST(void, expected), (expr))) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 1) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 0) : !!(expr))); \ + })) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) \ + (__extension__ ({ \ + double hedley_probability_ = (probability); \ + ((hedley_probability_ >= 0.9) ? __builtin_expect(!!(expr), 0) : ((hedley_probability_ <= 0.1) ? __builtin_expect(!!(expr), 1) : !!(expr))); \ + })) +# define JSON_HEDLEY_LIKELY(expr) __builtin_expect(!!(expr), 1) +# define JSON_HEDLEY_UNLIKELY(expr) __builtin_expect(!!(expr), 0) +#else +# define JSON_HEDLEY_PREDICT(expr, expected, probability) (JSON_HEDLEY_STATIC_CAST(void, expected), (expr)) +# define JSON_HEDLEY_PREDICT_TRUE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_PREDICT_FALSE(expr, probability) (!!(expr)) +# define JSON_HEDLEY_LIKELY(expr) (!!(expr)) +# define JSON_HEDLEY_UNLIKELY(expr) (!!(expr)) +#endif +#if !defined(JSON_HEDLEY_UNPREDICTABLE) + #define JSON_HEDLEY_UNPREDICTABLE(expr) JSON_HEDLEY_PREDICT(expr, 1, 0.5) +#endif + +#if defined(JSON_HEDLEY_MALLOC) + #undef JSON_HEDLEY_MALLOC +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(malloc) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_MALLOC __attribute__((__malloc__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_MALLOC _Pragma("returns_new_memory") +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_MALLOC __declspec(restrict) +#else + #define JSON_HEDLEY_MALLOC +#endif + +#if defined(JSON_HEDLEY_PURE) + #undef JSON_HEDLEY_PURE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(pure) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,96,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PURE __attribute__((__pure__)) +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) +# define JSON_HEDLEY_PURE _Pragma("does_not_write_global_data") +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(2,0,1) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) \ + ) +# define JSON_HEDLEY_PURE _Pragma("FUNC_IS_PURE;") +#else +# define JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_CONST) + #undef JSON_HEDLEY_CONST +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(const) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(2,5,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_CONST __attribute__((__const__)) +#elif \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) + #define JSON_HEDLEY_CONST _Pragma("no_side_effect") +#else + #define JSON_HEDLEY_CONST JSON_HEDLEY_PURE +#endif + +#if defined(JSON_HEDLEY_RESTRICT) + #undef JSON_HEDLEY_RESTRICT +#endif +#if defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT restrict +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(14,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(17,10,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,4) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,14,0) && defined(__cplusplus)) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) || \ + defined(__clang__) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RESTRICT __restrict +#elif JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,3,0) && !defined(__cplusplus) + #define JSON_HEDLEY_RESTRICT _Restrict +#else + #define JSON_HEDLEY_RESTRICT +#endif + +#if defined(JSON_HEDLEY_INLINE) + #undef JSON_HEDLEY_INLINE +#endif +#if \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L)) || \ + (defined(__cplusplus) && (__cplusplus >= 199711L)) + #define JSON_HEDLEY_INLINE inline +#elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(6,2,0) + #define JSON_HEDLEY_INLINE __inline__ +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,1,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(3,1,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,2,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(8,0,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_INLINE __inline +#else + #define JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_ALWAYS_INLINE) + #undef JSON_HEDLEY_ALWAYS_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(always_inline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) +# define JSON_HEDLEY_ALWAYS_INLINE __attribute__((__always_inline__)) JSON_HEDLEY_INLINE +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(12,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_ALWAYS_INLINE __forceinline +#elif defined(__cplusplus) && \ + ( \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) \ + ) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("FUNC_ALWAYS_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_ALWAYS_INLINE _Pragma("inline=forced") +#else +# define JSON_HEDLEY_ALWAYS_INLINE JSON_HEDLEY_INLINE +#endif + +#if defined(JSON_HEDLEY_NEVER_INLINE) + #undef JSON_HEDLEY_NEVER_INLINE +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(noinline) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(10,1,0) || \ + JSON_HEDLEY_TI_VERSION_CHECK(15,12,0) || \ + (JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(4,8,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_ARMCL_VERSION_CHECK(5,2,0) || \ + (JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL2000_VERSION_CHECK(6,4,0) || \ + (JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,0,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(4,3,0) || \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) || \ + JSON_HEDLEY_TI_CL7X_VERSION_CHECK(1,2,0) || \ + JSON_HEDLEY_TI_CLPRU_VERSION_CHECK(2,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) || \ + JSON_HEDLEY_IAR_VERSION_CHECK(8,10,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute__((__noinline__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,10,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#elif JSON_HEDLEY_PGI_VERSION_CHECK(10,2,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("noinline") +#elif JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,0,0) && defined(__cplusplus) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("FUNC_CANNOT_INLINE;") +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) + #define JSON_HEDLEY_NEVER_INLINE _Pragma("inline=never") +#elif JSON_HEDLEY_COMPCERT_VERSION_CHECK(3,2,0) + #define JSON_HEDLEY_NEVER_INLINE __attribute((noinline)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(9,0,0) + #define JSON_HEDLEY_NEVER_INLINE __declspec(noinline) +#else + #define JSON_HEDLEY_NEVER_INLINE +#endif + +#if defined(JSON_HEDLEY_PRIVATE) + #undef JSON_HEDLEY_PRIVATE +#endif +#if defined(JSON_HEDLEY_PUBLIC) + #undef JSON_HEDLEY_PUBLIC +#endif +#if defined(JSON_HEDLEY_IMPORT) + #undef JSON_HEDLEY_IMPORT +#endif +#if defined(_WIN32) || defined(__CYGWIN__) +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC __declspec(dllexport) +# define JSON_HEDLEY_IMPORT __declspec(dllimport) +#else +# if \ + JSON_HEDLEY_HAS_ATTRIBUTE(visibility) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,11,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + ( \ + defined(__TI_EABI__) && \ + ( \ + (JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,2,0) && defined(__TI_GNU_ATTRIBUTE_SUPPORT__)) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(7,5,0) \ + ) \ + ) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) +# define JSON_HEDLEY_PRIVATE __attribute__((__visibility__("hidden"))) +# define JSON_HEDLEY_PUBLIC __attribute__((__visibility__("default"))) +# else +# define JSON_HEDLEY_PRIVATE +# define JSON_HEDLEY_PUBLIC +# endif +# define JSON_HEDLEY_IMPORT extern +#endif + +#if defined(JSON_HEDLEY_NO_THROW) + #undef JSON_HEDLEY_NO_THROW +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(nothrow) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,3,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_NO_THROW __attribute__((__nothrow__)) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) + #define JSON_HEDLEY_NO_THROW __declspec(nothrow) +#else + #define JSON_HEDLEY_NO_THROW +#endif + +#if defined(JSON_HEDLEY_FALL_THROUGH) + #undef JSON_HEDLEY_FALL_THROUGH +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(fallthrough) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(7,0,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_FALL_THROUGH __attribute__((__fallthrough__)) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE_NS(clang,fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[clang::fallthrough]]) +#elif JSON_HEDLEY_HAS_CPP_ATTRIBUTE(fallthrough) + #define JSON_HEDLEY_FALL_THROUGH JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_([[fallthrough]]) +#elif defined(__fallthrough) /* SAL */ + #define JSON_HEDLEY_FALL_THROUGH __fallthrough +#else + #define JSON_HEDLEY_FALL_THROUGH +#endif + +#if defined(JSON_HEDLEY_RETURNS_NON_NULL) + #undef JSON_HEDLEY_RETURNS_NON_NULL +#endif +#if \ + JSON_HEDLEY_HAS_ATTRIBUTE(returns_nonnull) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_RETURNS_NON_NULL __attribute__((__returns_nonnull__)) +#elif defined(_Ret_notnull_) /* SAL */ + #define JSON_HEDLEY_RETURNS_NON_NULL _Ret_notnull_ +#else + #define JSON_HEDLEY_RETURNS_NON_NULL +#endif + +#if defined(JSON_HEDLEY_ARRAY_PARAM) + #undef JSON_HEDLEY_ARRAY_PARAM +#endif +#if \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901L) && \ + !defined(__STDC_NO_VLA__) && \ + !defined(__cplusplus) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_TINYC_VERSION) + #define JSON_HEDLEY_ARRAY_PARAM(name) (name) +#else + #define JSON_HEDLEY_ARRAY_PARAM(name) +#endif + +#if defined(JSON_HEDLEY_IS_CONSTANT) + #undef JSON_HEDLEY_IS_CONSTANT +#endif +#if defined(JSON_HEDLEY_REQUIRE_CONSTEXPR) + #undef JSON_HEDLEY_REQUIRE_CONSTEXPR +#endif +/* JSON_HEDLEY_IS_CONSTEXPR_ is for + HEDLEY INTERNAL USE ONLY. API subject to change without notice. */ +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #undef JSON_HEDLEY_IS_CONSTEXPR_ +#endif +#if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_constant_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,19) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(4,1,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_TI_CL6X_VERSION_CHECK(6,1,0) || \ + (JSON_HEDLEY_SUNPRO_VERSION_CHECK(5,10,0) && !defined(__cplusplus)) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_MCST_LCC_VERSION_CHECK(1,25,10) + #define JSON_HEDLEY_IS_CONSTANT(expr) __builtin_constant_p(expr) +#endif +#if !defined(__cplusplus) +# if \ + JSON_HEDLEY_HAS_BUILTIN(__builtin_types_compatible_p) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(3,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(13,1,0) || \ + JSON_HEDLEY_CRAY_VERSION_CHECK(8,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,4,0) || \ + JSON_HEDLEY_TINYC_VERSION_CHECK(0,9,24) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0)), int*) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) __builtin_types_compatible_p(__typeof__((1 ? (void*) ((intptr_t) ((expr) * 0)) : (int*) 0)), int*) +#endif +# elif \ + ( \ + defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L) && \ + !defined(JSON_HEDLEY_SUNPRO_VERSION) && \ + !defined(JSON_HEDLEY_PGI_VERSION) && \ + !defined(JSON_HEDLEY_IAR_VERSION)) || \ + (JSON_HEDLEY_HAS_EXTENSION(c_generic_selections) && !defined(JSON_HEDLEY_IAR_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,9,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(17,0,0) || \ + JSON_HEDLEY_IBM_VERSION_CHECK(12,1,0) || \ + JSON_HEDLEY_ARM_VERSION_CHECK(5,3,0) +#if defined(__INTPTR_TYPE__) + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((__INTPTR_TYPE__) ((expr) * 0)) : (int*) 0), int*: 1, void*: 0) +#else + #include + #define JSON_HEDLEY_IS_CONSTEXPR_(expr) _Generic((1 ? (void*) ((intptr_t) * 0) : (int*) 0), int*: 1, void*: 0) +#endif +# elif \ + defined(JSON_HEDLEY_GCC_VERSION) || \ + defined(JSON_HEDLEY_INTEL_VERSION) || \ + defined(JSON_HEDLEY_TINYC_VERSION) || \ + defined(JSON_HEDLEY_TI_ARMCL_VERSION) || \ + JSON_HEDLEY_TI_CL430_VERSION_CHECK(18,12,0) || \ + defined(JSON_HEDLEY_TI_CL2000_VERSION) || \ + defined(JSON_HEDLEY_TI_CL6X_VERSION) || \ + defined(JSON_HEDLEY_TI_CL7X_VERSION) || \ + defined(JSON_HEDLEY_TI_CLPRU_VERSION) || \ + defined(__clang__) +# define JSON_HEDLEY_IS_CONSTEXPR_(expr) ( \ + sizeof(void) != \ + sizeof(*( \ + 1 ? \ + ((void*) ((expr) * 0L) ) : \ +((struct { char v[sizeof(void) * 2]; } *) 1) \ + ) \ + ) \ + ) +# endif +#endif +#if defined(JSON_HEDLEY_IS_CONSTEXPR_) + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) JSON_HEDLEY_IS_CONSTEXPR_(expr) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (JSON_HEDLEY_IS_CONSTEXPR_(expr) ? (expr) : (-1)) +#else + #if !defined(JSON_HEDLEY_IS_CONSTANT) + #define JSON_HEDLEY_IS_CONSTANT(expr) (0) + #endif + #define JSON_HEDLEY_REQUIRE_CONSTEXPR(expr) (expr) +#endif + +#if defined(JSON_HEDLEY_BEGIN_C_DECLS) + #undef JSON_HEDLEY_BEGIN_C_DECLS +#endif +#if defined(JSON_HEDLEY_END_C_DECLS) + #undef JSON_HEDLEY_END_C_DECLS +#endif +#if defined(JSON_HEDLEY_C_DECL) + #undef JSON_HEDLEY_C_DECL +#endif +#if defined(__cplusplus) + #define JSON_HEDLEY_BEGIN_C_DECLS extern "C" { + #define JSON_HEDLEY_END_C_DECLS } + #define JSON_HEDLEY_C_DECL extern "C" +#else + #define JSON_HEDLEY_BEGIN_C_DECLS + #define JSON_HEDLEY_END_C_DECLS + #define JSON_HEDLEY_C_DECL +#endif + +#if defined(JSON_HEDLEY_STATIC_ASSERT) + #undef JSON_HEDLEY_STATIC_ASSERT +#endif +#if \ + !defined(__cplusplus) && ( \ + (defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 201112L)) || \ + (JSON_HEDLEY_HAS_FEATURE(c_static_assert) && !defined(JSON_HEDLEY_INTEL_CL_VERSION)) || \ + JSON_HEDLEY_GCC_VERSION_CHECK(6,0,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) || \ + defined(_Static_assert) \ + ) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) _Static_assert(expr, message) +#elif \ + (defined(__cplusplus) && (__cplusplus >= 201103L)) || \ + JSON_HEDLEY_MSVC_VERSION_CHECK(16,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(static_assert(expr, message)) +#else +# define JSON_HEDLEY_STATIC_ASSERT(expr, message) +#endif + +#if defined(JSON_HEDLEY_NULL) + #undef JSON_HEDLEY_NULL +#endif +#if defined(__cplusplus) + #if __cplusplus >= 201103L + #define JSON_HEDLEY_NULL JSON_HEDLEY_DIAGNOSTIC_DISABLE_CPP98_COMPAT_WRAP_(nullptr) + #elif defined(NULL) + #define JSON_HEDLEY_NULL NULL + #else + #define JSON_HEDLEY_NULL JSON_HEDLEY_STATIC_CAST(void*, 0) + #endif +#elif defined(NULL) + #define JSON_HEDLEY_NULL NULL +#else + #define JSON_HEDLEY_NULL ((void*) 0) +#endif + +#if defined(JSON_HEDLEY_MESSAGE) + #undef JSON_HEDLEY_MESSAGE +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_MESSAGE(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(message msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message msg) +#elif JSON_HEDLEY_CRAY_VERSION_CHECK(5,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(_CRI message msg) +#elif JSON_HEDLEY_IAR_VERSION_CHECK(8,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#elif JSON_HEDLEY_PELLES_VERSION_CHECK(2,0,0) +# define JSON_HEDLEY_MESSAGE(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_WARNING) + #undef JSON_HEDLEY_WARNING +#endif +#if JSON_HEDLEY_HAS_WARNING("-Wunknown-pragmas") +# define JSON_HEDLEY_WARNING(msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + JSON_HEDLEY_DIAGNOSTIC_DISABLE_UNKNOWN_PRAGMAS \ + JSON_HEDLEY_PRAGMA(clang warning msg) \ + JSON_HEDLEY_DIAGNOSTIC_POP +#elif \ + JSON_HEDLEY_GCC_VERSION_CHECK(4,8,0) || \ + JSON_HEDLEY_PGI_VERSION_CHECK(18,4,0) || \ + JSON_HEDLEY_INTEL_VERSION_CHECK(13,0,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(GCC warning msg) +#elif \ + JSON_HEDLEY_MSVC_VERSION_CHECK(15,0,0) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_PRAGMA(message(msg)) +#else +# define JSON_HEDLEY_WARNING(msg) JSON_HEDLEY_MESSAGE(msg) +#endif + +#if defined(JSON_HEDLEY_REQUIRE) + #undef JSON_HEDLEY_REQUIRE +#endif +#if defined(JSON_HEDLEY_REQUIRE_MSG) + #undef JSON_HEDLEY_REQUIRE_MSG +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(diagnose_if) +# if JSON_HEDLEY_HAS_WARNING("-Wgcc-compat") +# define JSON_HEDLEY_REQUIRE(expr) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), #expr, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("clang diagnostic ignored \"-Wgcc-compat\"") \ + __attribute__((diagnose_if(!(expr), msg, "error"))) \ + JSON_HEDLEY_DIAGNOSTIC_POP +# else +# define JSON_HEDLEY_REQUIRE(expr) __attribute__((diagnose_if(!(expr), #expr, "error"))) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) __attribute__((diagnose_if(!(expr), msg, "error"))) +# endif +#else +# define JSON_HEDLEY_REQUIRE(expr) +# define JSON_HEDLEY_REQUIRE_MSG(expr,msg) +#endif + +#if defined(JSON_HEDLEY_FLAGS) + #undef JSON_HEDLEY_FLAGS +#endif +#if JSON_HEDLEY_HAS_ATTRIBUTE(flag_enum) && (!defined(__cplusplus) || JSON_HEDLEY_HAS_WARNING("-Wbitfield-enum-conversion")) + #define JSON_HEDLEY_FLAGS __attribute__((__flag_enum__)) +#else + #define JSON_HEDLEY_FLAGS +#endif + +#if defined(JSON_HEDLEY_FLAGS_CAST) + #undef JSON_HEDLEY_FLAGS_CAST +#endif +#if JSON_HEDLEY_INTEL_VERSION_CHECK(19,0,0) +# define JSON_HEDLEY_FLAGS_CAST(T, expr) (__extension__ ({ \ + JSON_HEDLEY_DIAGNOSTIC_PUSH \ + _Pragma("warning(disable:188)") \ + ((T) (expr)); \ + JSON_HEDLEY_DIAGNOSTIC_POP \ + })) +#else +# define JSON_HEDLEY_FLAGS_CAST(T, expr) JSON_HEDLEY_STATIC_CAST(T, expr) +#endif + +#if defined(JSON_HEDLEY_EMPTY_BASES) + #undef JSON_HEDLEY_EMPTY_BASES +#endif +#if \ + (JSON_HEDLEY_MSVC_VERSION_CHECK(19,0,23918) && !JSON_HEDLEY_MSVC_VERSION_CHECK(20,0,0)) || \ + JSON_HEDLEY_INTEL_CL_VERSION_CHECK(2021,1,0) + #define JSON_HEDLEY_EMPTY_BASES __declspec(empty_bases) +#else + #define JSON_HEDLEY_EMPTY_BASES +#endif + +/* Remaining macros are deprecated. */ + +#if defined(JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK) + #undef JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK +#endif +#if defined(__clang__) + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) (0) +#else + #define JSON_HEDLEY_GCC_NOT_CLANG_VERSION_CHECK(major,minor,patch) JSON_HEDLEY_GCC_VERSION_CHECK(major,minor,patch) +#endif + +#if defined(JSON_HEDLEY_CLANG_HAS_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_CPP_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_CPP_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_BUILTIN) + #undef JSON_HEDLEY_CLANG_HAS_BUILTIN +#endif +#define JSON_HEDLEY_CLANG_HAS_BUILTIN(builtin) JSON_HEDLEY_HAS_BUILTIN(builtin) + +#if defined(JSON_HEDLEY_CLANG_HAS_FEATURE) + #undef JSON_HEDLEY_CLANG_HAS_FEATURE +#endif +#define JSON_HEDLEY_CLANG_HAS_FEATURE(feature) JSON_HEDLEY_HAS_FEATURE(feature) + +#if defined(JSON_HEDLEY_CLANG_HAS_EXTENSION) + #undef JSON_HEDLEY_CLANG_HAS_EXTENSION +#endif +#define JSON_HEDLEY_CLANG_HAS_EXTENSION(extension) JSON_HEDLEY_HAS_EXTENSION(extension) + +#if defined(JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE) + #undef JSON_HEDLEY_CLANG_HAS_DECLSPEC_DECLSPEC_ATTRIBUTE +#endif +#define JSON_HEDLEY_CLANG_HAS_DECLSPEC_ATTRIBUTE(attribute) JSON_HEDLEY_HAS_DECLSPEC_ATTRIBUTE(attribute) + +#if defined(JSON_HEDLEY_CLANG_HAS_WARNING) + #undef JSON_HEDLEY_CLANG_HAS_WARNING +#endif +#define JSON_HEDLEY_CLANG_HAS_WARNING(warning) JSON_HEDLEY_HAS_WARNING(warning) + +#endif /* !defined(JSON_HEDLEY_VERSION) || (JSON_HEDLEY_VERSION < X) */ + + +// This file contains all internal macro definitions (except those affecting ABI) +// You MUST include macro_unscope.hpp at the end of json.hpp to undef all of them + +// #include + + +// exclude unsupported compilers +#if !defined(JSON_SKIP_UNSUPPORTED_COMPILER_CHECK) + #if defined(__clang__) + #if (__clang_major__ * 10000 + __clang_minor__ * 100 + __clang_patchlevel__) < 30400 + #error "unsupported Clang version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #elif defined(__GNUC__) && !(defined(__ICC) || defined(__INTEL_COMPILER)) + #if (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) < 40800 + #error "unsupported GCC version - see https://github.com/nlohmann/json#supported-compilers" + #endif + #endif +#endif + +// C++ language standard detection +// if the user manually specified the used c++ version this is skipped +#if !defined(JSON_HAS_CPP_20) && !defined(JSON_HAS_CPP_17) && !defined(JSON_HAS_CPP_14) && !defined(JSON_HAS_CPP_11) + #if (defined(__cplusplus) && __cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L) + #define JSON_HAS_CPP_20 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464 + #define JSON_HAS_CPP_17 + #define JSON_HAS_CPP_14 + #elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1) + #define JSON_HAS_CPP_14 + #endif + // the cpp 11 flag is always specified because it is the minimal required version + #define JSON_HAS_CPP_11 +#endif + +#ifdef __has_include + #if __has_include() + #include + #endif +#endif + +#if !defined(JSON_HAS_FILESYSTEM) && !defined(JSON_HAS_EXPERIMENTAL_FILESYSTEM) + #ifdef JSON_HAS_CPP_17 + #if defined(__cpp_lib_filesystem) + #define JSON_HAS_FILESYSTEM 1 + #elif defined(__cpp_lib_experimental_filesystem) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif !defined(__has_include) + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_FILESYSTEM 1 + #elif __has_include() + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 1 + #endif + + // std::filesystem does not work on MinGW GCC 8: https://sourceforge.net/p/mingw-w64/bugs/737/ + #if defined(__MINGW32__) && defined(__GNUC__) && __GNUC__ == 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before GCC 8: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ < 8 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before Clang 7: https://en.cppreference.com/w/cpp/compiler_support + #if defined(__clang_major__) && __clang_major__ < 7 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before MSVC 19.14: https://en.cppreference.com/w/cpp/compiler_support + #if defined(_MSC_VER) && _MSC_VER < 1914 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before iOS 13 + #if defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && __IPHONE_OS_VERSION_MIN_REQUIRED < 130000 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + + // no filesystem support before macOS Catalina + #if defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && __MAC_OS_X_VERSION_MIN_REQUIRED < 101500 + #undef JSON_HAS_FILESYSTEM + #undef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #endif + #endif +#endif + +#ifndef JSON_HAS_EXPERIMENTAL_FILESYSTEM + #define JSON_HAS_EXPERIMENTAL_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_FILESYSTEM + #define JSON_HAS_FILESYSTEM 0 +#endif + +#ifndef JSON_HAS_THREE_WAY_COMPARISON + #if defined(__cpp_impl_three_way_comparison) && __cpp_impl_three_way_comparison >= 201907L \ + && defined(__cpp_lib_three_way_comparison) && __cpp_lib_three_way_comparison >= 201907L + #define JSON_HAS_THREE_WAY_COMPARISON 1 + #else + #define JSON_HAS_THREE_WAY_COMPARISON 0 + #endif +#endif + +#ifndef JSON_HAS_RANGES + // ranges header shipping in GCC 11.1.0 (released 2021-04-27) has syntax error + #if defined(__GLIBCXX__) && __GLIBCXX__ == 20210427 + #define JSON_HAS_RANGES 0 + #elif defined(__cpp_lib_ranges) + #define JSON_HAS_RANGES 1 + #else + #define JSON_HAS_RANGES 0 + #endif +#endif + +#ifndef JSON_HAS_STATIC_RTTI + #if !defined(_HAS_STATIC_RTTI) || _HAS_STATIC_RTTI != 0 + #define JSON_HAS_STATIC_RTTI 1 + #else + #define JSON_HAS_STATIC_RTTI 0 + #endif +#endif + +#ifdef JSON_HAS_CPP_17 + #define JSON_INLINE_VARIABLE inline +#else + #define JSON_INLINE_VARIABLE +#endif + +#if JSON_HEDLEY_HAS_ATTRIBUTE(no_unique_address) + #define JSON_NO_UNIQUE_ADDRESS [[no_unique_address]] +#else + #define JSON_NO_UNIQUE_ADDRESS +#endif + +// disable documentation warnings on clang +#if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wdocumentation" + #pragma clang diagnostic ignored "-Wdocumentation-unknown-command" +#endif + +// allow disabling exceptions +#if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION) + #define JSON_THROW(exception) throw exception + #define JSON_TRY try + #define JSON_CATCH(exception) catch(exception) + #define JSON_INTERNAL_CATCH(exception) catch(exception) +#else + #include + #define JSON_THROW(exception) std::abort() + #define JSON_TRY if(true) + #define JSON_CATCH(exception) if(false) + #define JSON_INTERNAL_CATCH(exception) if(false) +#endif + +// override exception macros +#if defined(JSON_THROW_USER) + #undef JSON_THROW + #define JSON_THROW JSON_THROW_USER +#endif +#if defined(JSON_TRY_USER) + #undef JSON_TRY + #define JSON_TRY JSON_TRY_USER +#endif +#if defined(JSON_CATCH_USER) + #undef JSON_CATCH + #define JSON_CATCH JSON_CATCH_USER + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_CATCH_USER +#endif +#if defined(JSON_INTERNAL_CATCH_USER) + #undef JSON_INTERNAL_CATCH + #define JSON_INTERNAL_CATCH JSON_INTERNAL_CATCH_USER +#endif + +// allow overriding assert +#if !defined(JSON_ASSERT) + #include // assert + #define JSON_ASSERT(x) assert(x) +#endif + +// allow to access some private functions (needed by the test suite) +#if defined(JSON_TESTS_PRIVATE) + #define JSON_PRIVATE_UNLESS_TESTED public +#else + #define JSON_PRIVATE_UNLESS_TESTED private +#endif + +/*! +@brief macro to briefly define a mapping between an enum and JSON +@def NLOHMANN_JSON_SERIALIZE_ENUM +@since version 3.4.0 +*/ +#define NLOHMANN_JSON_SERIALIZE_ENUM(ENUM_TYPE, ...) \ + template \ + inline void to_json(BasicJsonType& j, const ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [e](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.first == e; \ + }); \ + j = ((it != std::end(m)) ? it : std::begin(m))->second; \ + } \ + template \ + inline void from_json(const BasicJsonType& j, ENUM_TYPE& e) \ + { \ + static_assert(std::is_enum::value, #ENUM_TYPE " must be an enum!"); \ + static const std::pair m[] = __VA_ARGS__; \ + auto it = std::find_if(std::begin(m), std::end(m), \ + [&j](const std::pair& ej_pair) -> bool \ + { \ + return ej_pair.second == j; \ + }); \ + e = ((it != std::end(m)) ? it : std::begin(m))->first; \ + } + +// Ugly macros to avoid uglier copy-paste when specializing basic_json. They +// may be removed in the future once the class is split. + +#define NLOHMANN_BASIC_JSON_TPL_DECLARATION \ + template class ObjectType, \ + template class ArrayType, \ + class StringType, class BooleanType, class NumberIntegerType, \ + class NumberUnsignedType, class NumberFloatType, \ + template class AllocatorType, \ + template class JSONSerializer, \ + class BinaryType, \ + class CustomBaseClass> + +#define NLOHMANN_BASIC_JSON_TPL \ + basic_json + +// Macros to simplify conversion from/to types + +#define NLOHMANN_JSON_EXPAND( x ) x +#define NLOHMANN_JSON_GET_MACRO(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63, _64, NAME,...) NAME +#define NLOHMANN_JSON_PASTE(...) NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_GET_MACRO(__VA_ARGS__, \ + NLOHMANN_JSON_PASTE64, \ + NLOHMANN_JSON_PASTE63, \ + NLOHMANN_JSON_PASTE62, \ + NLOHMANN_JSON_PASTE61, \ + NLOHMANN_JSON_PASTE60, \ + NLOHMANN_JSON_PASTE59, \ + NLOHMANN_JSON_PASTE58, \ + NLOHMANN_JSON_PASTE57, \ + NLOHMANN_JSON_PASTE56, \ + NLOHMANN_JSON_PASTE55, \ + NLOHMANN_JSON_PASTE54, \ + NLOHMANN_JSON_PASTE53, \ + NLOHMANN_JSON_PASTE52, \ + NLOHMANN_JSON_PASTE51, \ + NLOHMANN_JSON_PASTE50, \ + NLOHMANN_JSON_PASTE49, \ + NLOHMANN_JSON_PASTE48, \ + NLOHMANN_JSON_PASTE47, \ + NLOHMANN_JSON_PASTE46, \ + NLOHMANN_JSON_PASTE45, \ + NLOHMANN_JSON_PASTE44, \ + NLOHMANN_JSON_PASTE43, \ + NLOHMANN_JSON_PASTE42, \ + NLOHMANN_JSON_PASTE41, \ + NLOHMANN_JSON_PASTE40, \ + NLOHMANN_JSON_PASTE39, \ + NLOHMANN_JSON_PASTE38, \ + NLOHMANN_JSON_PASTE37, \ + NLOHMANN_JSON_PASTE36, \ + NLOHMANN_JSON_PASTE35, \ + NLOHMANN_JSON_PASTE34, \ + NLOHMANN_JSON_PASTE33, \ + NLOHMANN_JSON_PASTE32, \ + NLOHMANN_JSON_PASTE31, \ + NLOHMANN_JSON_PASTE30, \ + NLOHMANN_JSON_PASTE29, \ + NLOHMANN_JSON_PASTE28, \ + NLOHMANN_JSON_PASTE27, \ + NLOHMANN_JSON_PASTE26, \ + NLOHMANN_JSON_PASTE25, \ + NLOHMANN_JSON_PASTE24, \ + NLOHMANN_JSON_PASTE23, \ + NLOHMANN_JSON_PASTE22, \ + NLOHMANN_JSON_PASTE21, \ + NLOHMANN_JSON_PASTE20, \ + NLOHMANN_JSON_PASTE19, \ + NLOHMANN_JSON_PASTE18, \ + NLOHMANN_JSON_PASTE17, \ + NLOHMANN_JSON_PASTE16, \ + NLOHMANN_JSON_PASTE15, \ + NLOHMANN_JSON_PASTE14, \ + NLOHMANN_JSON_PASTE13, \ + NLOHMANN_JSON_PASTE12, \ + NLOHMANN_JSON_PASTE11, \ + NLOHMANN_JSON_PASTE10, \ + NLOHMANN_JSON_PASTE9, \ + NLOHMANN_JSON_PASTE8, \ + NLOHMANN_JSON_PASTE7, \ + NLOHMANN_JSON_PASTE6, \ + NLOHMANN_JSON_PASTE5, \ + NLOHMANN_JSON_PASTE4, \ + NLOHMANN_JSON_PASTE3, \ + NLOHMANN_JSON_PASTE2, \ + NLOHMANN_JSON_PASTE1)(__VA_ARGS__)) +#define NLOHMANN_JSON_PASTE2(func, v1) func(v1) +#define NLOHMANN_JSON_PASTE3(func, v1, v2) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE2(func, v2) +#define NLOHMANN_JSON_PASTE4(func, v1, v2, v3) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE3(func, v2, v3) +#define NLOHMANN_JSON_PASTE5(func, v1, v2, v3, v4) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE4(func, v2, v3, v4) +#define NLOHMANN_JSON_PASTE6(func, v1, v2, v3, v4, v5) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE5(func, v2, v3, v4, v5) +#define NLOHMANN_JSON_PASTE7(func, v1, v2, v3, v4, v5, v6) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE6(func, v2, v3, v4, v5, v6) +#define NLOHMANN_JSON_PASTE8(func, v1, v2, v3, v4, v5, v6, v7) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE7(func, v2, v3, v4, v5, v6, v7) +#define NLOHMANN_JSON_PASTE9(func, v1, v2, v3, v4, v5, v6, v7, v8) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE8(func, v2, v3, v4, v5, v6, v7, v8) +#define NLOHMANN_JSON_PASTE10(func, v1, v2, v3, v4, v5, v6, v7, v8, v9) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE9(func, v2, v3, v4, v5, v6, v7, v8, v9) +#define NLOHMANN_JSON_PASTE11(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE10(func, v2, v3, v4, v5, v6, v7, v8, v9, v10) +#define NLOHMANN_JSON_PASTE12(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE11(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11) +#define NLOHMANN_JSON_PASTE13(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE12(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12) +#define NLOHMANN_JSON_PASTE14(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE13(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13) +#define NLOHMANN_JSON_PASTE15(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE14(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14) +#define NLOHMANN_JSON_PASTE16(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE15(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) +#define NLOHMANN_JSON_PASTE17(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE16(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16) +#define NLOHMANN_JSON_PASTE18(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE17(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17) +#define NLOHMANN_JSON_PASTE19(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE18(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18) +#define NLOHMANN_JSON_PASTE20(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE19(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19) +#define NLOHMANN_JSON_PASTE21(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE20(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20) +#define NLOHMANN_JSON_PASTE22(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE21(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21) +#define NLOHMANN_JSON_PASTE23(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE22(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22) +#define NLOHMANN_JSON_PASTE24(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE23(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23) +#define NLOHMANN_JSON_PASTE25(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE24(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24) +#define NLOHMANN_JSON_PASTE26(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE25(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25) +#define NLOHMANN_JSON_PASTE27(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE26(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26) +#define NLOHMANN_JSON_PASTE28(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE27(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27) +#define NLOHMANN_JSON_PASTE29(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE28(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28) +#define NLOHMANN_JSON_PASTE30(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE29(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29) +#define NLOHMANN_JSON_PASTE31(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE30(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30) +#define NLOHMANN_JSON_PASTE32(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE31(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31) +#define NLOHMANN_JSON_PASTE33(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE32(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32) +#define NLOHMANN_JSON_PASTE34(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE33(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33) +#define NLOHMANN_JSON_PASTE35(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE34(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34) +#define NLOHMANN_JSON_PASTE36(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE35(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35) +#define NLOHMANN_JSON_PASTE37(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE36(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36) +#define NLOHMANN_JSON_PASTE38(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE37(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37) +#define NLOHMANN_JSON_PASTE39(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE38(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38) +#define NLOHMANN_JSON_PASTE40(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE39(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39) +#define NLOHMANN_JSON_PASTE41(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE40(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40) +#define NLOHMANN_JSON_PASTE42(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE41(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41) +#define NLOHMANN_JSON_PASTE43(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE42(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42) +#define NLOHMANN_JSON_PASTE44(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE43(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43) +#define NLOHMANN_JSON_PASTE45(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE44(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44) +#define NLOHMANN_JSON_PASTE46(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE45(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45) +#define NLOHMANN_JSON_PASTE47(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE46(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46) +#define NLOHMANN_JSON_PASTE48(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE47(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47) +#define NLOHMANN_JSON_PASTE49(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE48(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48) +#define NLOHMANN_JSON_PASTE50(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE49(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49) +#define NLOHMANN_JSON_PASTE51(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE50(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50) +#define NLOHMANN_JSON_PASTE52(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE51(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51) +#define NLOHMANN_JSON_PASTE53(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE52(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52) +#define NLOHMANN_JSON_PASTE54(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE53(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53) +#define NLOHMANN_JSON_PASTE55(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE54(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54) +#define NLOHMANN_JSON_PASTE56(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE55(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55) +#define NLOHMANN_JSON_PASTE57(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE56(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56) +#define NLOHMANN_JSON_PASTE58(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE57(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57) +#define NLOHMANN_JSON_PASTE59(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE58(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58) +#define NLOHMANN_JSON_PASTE60(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE59(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59) +#define NLOHMANN_JSON_PASTE61(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE60(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60) +#define NLOHMANN_JSON_PASTE62(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE61(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61) +#define NLOHMANN_JSON_PASTE63(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE62(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62) +#define NLOHMANN_JSON_PASTE64(func, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) NLOHMANN_JSON_PASTE2(func, v1) NLOHMANN_JSON_PASTE63(func, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50, v51, v52, v53, v54, v55, v56, v57, v58, v59, v60, v61, v62, v63) + +#define NLOHMANN_JSON_TO(v1) nlohmann_json_j[#v1] = nlohmann_json_t.v1; +#define NLOHMANN_JSON_FROM(v1) nlohmann_json_j.at(#v1).get_to(nlohmann_json_t.v1); +#define NLOHMANN_JSON_FROM_WITH_DEFAULT(v1) nlohmann_json_t.v1 = nlohmann_json_j.value(#v1, nlohmann_json_default_obj.v1); + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + friend void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + friend void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +/*! +@brief macro +@def NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE +@since version 3.9.0 +*/ +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_ONLY_SERIALIZE(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } + +#define NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Type, ...) \ + inline void to_json(nlohmann::json& nlohmann_json_j, const Type& nlohmann_json_t) { NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_TO, __VA_ARGS__)) } \ + inline void from_json(const nlohmann::json& nlohmann_json_j, Type& nlohmann_json_t) { const Type nlohmann_json_default_obj{}; NLOHMANN_JSON_EXPAND(NLOHMANN_JSON_PASTE(NLOHMANN_JSON_FROM_WITH_DEFAULT, __VA_ARGS__)) } + +// inspired from https://stackoverflow.com/a/26745591 +// allows to call any std function as if (e.g. with begin): +// using std::begin; begin(x); +// +// it allows using the detected idiom to retrieve the return type +// of such an expression +#define NLOHMANN_CAN_CALL_STD_FUNC_IMPL(std_name) \ + namespace detail { \ + using std::std_name; \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + } \ + \ + namespace detail2 { \ + struct std_name##_tag \ + { \ + }; \ + \ + template \ + std_name##_tag std_name(T&&...); \ + \ + template \ + using result_of_##std_name = decltype(std_name(std::declval()...)); \ + \ + template \ + struct would_call_std_##std_name \ + { \ + static constexpr auto const value = ::nlohmann::detail:: \ + is_detected_exact::value; \ + }; \ + } /* namespace detail2 */ \ + \ + template \ + struct would_call_std_##std_name : detail2::would_call_std_##std_name \ + { \ + } + +#ifndef JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_USE_IMPLICIT_CONVERSIONS 1 +#endif + +#if JSON_USE_IMPLICIT_CONVERSIONS + #define JSON_EXPLICIT +#else + #define JSON_EXPLICIT explicit +#endif + +#ifndef JSON_DISABLE_ENUM_SERIALIZATION + #define JSON_DISABLE_ENUM_SERIALIZATION 0 +#endif + +#ifndef JSON_USE_GLOBAL_UDLS + #define JSON_USE_GLOBAL_UDLS 1 +#endif + +#if JSON_HAS_THREE_WAY_COMPARISON + #include // partial_ordering +#endif + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/////////////////////////// +// JSON type enumeration // +/////////////////////////// + +/*! +@brief the JSON type enumeration + +This enumeration collects the different JSON types. It is internally used to +distinguish the stored values, and the functions @ref basic_json::is_null(), +@ref basic_json::is_object(), @ref basic_json::is_array(), +@ref basic_json::is_string(), @ref basic_json::is_boolean(), +@ref basic_json::is_number() (with @ref basic_json::is_number_integer(), +@ref basic_json::is_number_unsigned(), and @ref basic_json::is_number_float()), +@ref basic_json::is_discarded(), @ref basic_json::is_primitive(), and +@ref basic_json::is_structured() rely on it. + +@note There are three enumeration entries (number_integer, number_unsigned, and +number_float), because the library distinguishes these three types for numbers: +@ref basic_json::number_unsigned_t is used for unsigned integers, +@ref basic_json::number_integer_t is used for signed integers, and +@ref basic_json::number_float_t is used for floating-point numbers or to +approximate integers which do not fit in the limits of their respective type. + +@sa see @ref basic_json::basic_json(const value_t value_type) -- create a JSON +value with the default value for a given type + +@since version 1.0.0 +*/ +enum class value_t : std::uint8_t +{ + null, ///< null value + object, ///< object (unordered set of name/value pairs) + array, ///< array (ordered collection of values) + string, ///< string value + boolean, ///< boolean value + number_integer, ///< number value (signed integer) + number_unsigned, ///< number value (unsigned integer) + number_float, ///< number value (floating-point) + binary, ///< binary array (ordered collection of bytes) + discarded ///< discarded by the parser callback function +}; + +/*! +@brief comparison operator for JSON types + +Returns an ordering that is similar to Python: +- order: null < boolean < number < object < array < string < binary +- furthermore, each type is not smaller than itself +- discarded values are not comparable +- binary is represented as a b"" string in python and directly comparable to a + string; however, making a binary array directly comparable with a string would + be surprising behavior in a JSON file. + +@since version 1.0.0 +*/ +#if JSON_HAS_THREE_WAY_COMPARISON + inline std::partial_ordering operator<=>(const value_t lhs, const value_t rhs) noexcept // *NOPAD* +#else + inline bool operator<(const value_t lhs, const value_t rhs) noexcept +#endif +{ + static constexpr std::array order = {{ + 0 /* null */, 3 /* object */, 4 /* array */, 5 /* string */, + 1 /* boolean */, 2 /* integer */, 2 /* unsigned */, 2 /* float */, + 6 /* binary */ + } + }; + + const auto l_index = static_cast(lhs); + const auto r_index = static_cast(rhs); +#if JSON_HAS_THREE_WAY_COMPARISON + if (l_index < order.size() && r_index < order.size()) + { + return order[l_index] <=> order[r_index]; // *NOPAD* + } + return std::partial_ordering::unordered; +#else + return l_index < order.size() && r_index < order.size() && order[l_index] < order[r_index]; +#endif +} + +// GCC selects the built-in operator< over an operator rewritten from +// a user-defined spaceship operator +// Clang, MSVC, and ICC select the rewritten candidate +// (see GCC bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105200) +#if JSON_HAS_THREE_WAY_COMPARISON && defined(__GNUC__) +inline bool operator<(const value_t lhs, const value_t rhs) noexcept +{ + return std::is_lt(lhs <=> rhs); // *NOPAD* +} +#endif + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/*! +@brief replace all occurrences of a substring by another string + +@param[in,out] s the string to manipulate; changed so that all + occurrences of @a f are replaced with @a t +@param[in] f the substring to replace with @a t +@param[in] t the string to replace @a f + +@pre The search string @a f must not be empty. **This precondition is +enforced with an assertion.** + +@since version 2.0.0 +*/ +template +inline void replace_substring(StringType& s, const StringType& f, + const StringType& t) +{ + JSON_ASSERT(!f.empty()); + for (auto pos = s.find(f); // find first occurrence of f + pos != StringType::npos; // make sure f was found + s.replace(pos, f.size(), t), // replace with t, and + pos = s.find(f, pos + t.size())) // find next occurrence of f + {} +} + +/*! + * @brief string escaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to escape + * @return escaped string + * + * Note the order of escaping "~" to "~0" and "/" to "~1" is important. + */ +template +inline StringType escape(StringType s) +{ + replace_substring(s, StringType{"~"}, StringType{"~0"}); + replace_substring(s, StringType{"/"}, StringType{"~1"}); + return s; +} + +/*! + * @brief string unescaping as described in RFC 6901 (Sect. 4) + * @param[in] s string to unescape + * @return unescaped string + * + * Note the order of escaping "~1" to "/" and "~0" to "~" is important. + */ +template +static void unescape(StringType& s) +{ + replace_substring(s, StringType{"~1"}, StringType{"/"}); + replace_substring(s, StringType{"~0"}, StringType{"~"}); +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // size_t + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +/// struct to capture the start position of the current token +struct position_t +{ + /// the total number of characters read + std::size_t chars_read_total = 0; + /// the number of characters read in the current line + std::size_t chars_read_current_line = 0; + /// the number of lines read + std::size_t lines_read = 0; + + /// conversion to size_t to preserve SAX interface + constexpr operator size_t() const + { + return chars_read_total; + } +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-FileCopyrightText: 2018 The Abseil Authors +// SPDX-License-Identifier: MIT + + + +#include // array +#include // size_t +#include // conditional, enable_if, false_type, integral_constant, is_constructible, is_integral, is_same, remove_cv, remove_reference, true_type +#include // index_sequence, make_index_sequence, index_sequence_for + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +using uncvref_t = typename std::remove_cv::type>::type; + +#ifdef JSON_HAS_CPP_14 + +// the following utilities are natively available in C++14 +using std::enable_if_t; +using std::index_sequence; +using std::make_index_sequence; +using std::index_sequence_for; + +#else + +// alias templates to reduce boilerplate +template +using enable_if_t = typename std::enable_if::type; + +// The following code is taken from https://github.com/abseil/abseil-cpp/blob/10cb35e459f5ecca5b2ff107635da0bfa41011b4/absl/utility/utility.h +// which is part of Google Abseil (https://github.com/abseil/abseil-cpp), licensed under the Apache License 2.0. + +//// START OF CODE FROM GOOGLE ABSEIL + +// integer_sequence +// +// Class template representing a compile-time integer sequence. An instantiation +// of `integer_sequence` has a sequence of integers encoded in its +// type through its template arguments (which is a common need when +// working with C++11 variadic templates). `absl::integer_sequence` is designed +// to be a drop-in replacement for C++14's `std::integer_sequence`. +// +// Example: +// +// template< class T, T... Ints > +// void user_function(integer_sequence); +// +// int main() +// { +// // user_function's `T` will be deduced to `int` and `Ints...` +// // will be deduced to `0, 1, 2, 3, 4`. +// user_function(make_integer_sequence()); +// } +template +struct integer_sequence +{ + using value_type = T; + static constexpr std::size_t size() noexcept + { + return sizeof...(Ints); + } +}; + +// index_sequence +// +// A helper template for an `integer_sequence` of `size_t`, +// `absl::index_sequence` is designed to be a drop-in replacement for C++14's +// `std::index_sequence`. +template +using index_sequence = integer_sequence; + +namespace utility_internal +{ + +template +struct Extend; + +// Note that SeqSize == sizeof...(Ints). It's passed explicitly for efficiency. +template +struct Extend, SeqSize, 0> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)... >; +}; + +template +struct Extend, SeqSize, 1> +{ + using type = integer_sequence < T, Ints..., (Ints + SeqSize)..., 2 * SeqSize >; +}; + +// Recursion helper for 'make_integer_sequence'. +// 'Gen::type' is an alias for 'integer_sequence'. +template +struct Gen +{ + using type = + typename Extend < typename Gen < T, N / 2 >::type, N / 2, N % 2 >::type; +}; + +template +struct Gen +{ + using type = integer_sequence; +}; + +} // namespace utility_internal + +// Compile-time sequences of integers + +// make_integer_sequence +// +// This template alias is equivalent to +// `integer_sequence`, and is designed to be a drop-in +// replacement for C++14's `std::make_integer_sequence`. +template +using make_integer_sequence = typename utility_internal::Gen::type; + +// make_index_sequence +// +// This template alias is equivalent to `index_sequence<0, 1, ..., N-1>`, +// and is designed to be a drop-in replacement for C++14's +// `std::make_index_sequence`. +template +using make_index_sequence = make_integer_sequence; + +// index_sequence_for +// +// Converts a typename pack into an index sequence of the same length, and +// is designed to be a drop-in replacement for C++14's +// `std::index_sequence_for()` +template +using index_sequence_for = make_index_sequence; + +//// END OF CODE FROM GOOGLE ABSEIL + +#endif + +// dispatch utility (taken from ranges-v3) +template struct priority_tag : priority_tag < N - 1 > {}; +template<> struct priority_tag<0> {}; + +// taken from ranges-v3 +template +struct static_const +{ + static JSON_INLINE_VARIABLE constexpr T value{}; +}; + +#ifndef JSON_HAS_CPP_17 + template + constexpr T static_const::value; +#endif + +template +inline constexpr std::array make_array(Args&& ... args) +{ + return std::array {{static_cast(std::forward(args))...}}; +} + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // numeric_limits +#include // false_type, is_constructible, is_integral, is_same, true_type +#include // declval +#include // tuple +#include // char_traits + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +#include // random_access_iterator_tag + +// #include + +// #include + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN +namespace detail +{ + +template +struct iterator_types {}; + +template +struct iterator_types < + It, + void_t> +{ + using difference_type = typename It::difference_type; + using value_type = typename It::value_type; + using pointer = typename It::pointer; + using reference = typename It::reference; + using iterator_category = typename It::iterator_category; +}; + +// This is required as some compilers implement std::iterator_traits in a way that +// doesn't work with SFINAE. See https://github.com/nlohmann/json/issues/1341. +template +struct iterator_traits +{ +}; + +template +struct iterator_traits < T, enable_if_t < !std::is_pointer::value >> + : iterator_types +{ +}; + +template +struct iterator_traits::value>> +{ + using iterator_category = std::random_access_iterator_tag; + using value_type = T; + using difference_type = ptrdiff_t; + using pointer = T*; + using reference = T&; +}; + +} // namespace detail +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(begin); + +NLOHMANN_JSON_NAMESPACE_END + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + + + +// #include + + +NLOHMANN_JSON_NAMESPACE_BEGIN + +NLOHMANN_CAN_CALL_STD_FUNC_IMPL(end); + +NLOHMANN_JSON_NAMESPACE_END + +// #include + +// #include + +// #include +// __ _____ _____ _____ +// __| | __| | | | JSON for Modern C++ +// | | |__ | | | | | | version 3.11.3 +// |_____|_____|_____|_|___| https://github.com/nlohmann/json +// +// SPDX-FileCopyrightText: 2013-2023 Niels Lohmann +// SPDX-License-Identifier: MIT + +#ifndef INCLUDE_NLOHMANN_JSON_FWD_HPP_ + #define INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + #include // int64_t, uint64_t + #include // map + #include // allocator + #include // string + #include // vector + + // #include + + + /*! + @brief namespace for Niels Lohmann + @see https://github.com/nlohmann + @since version 1.0.0 + */ + NLOHMANN_JSON_NAMESPACE_BEGIN + + /*! + @brief default JSONSerializer template argument + + This serializer ignores the template arguments and uses ADL + ([argument-dependent lookup](https://en.cppreference.com/w/cpp/language/adl)) + for serialization. + */ + template + struct adl_serializer; + + /// a class to store JSON values + /// @sa https://json.nlohmann.me/api/basic_json/ + template class ObjectType = + std::map, + template class ArrayType = std::vector, + class StringType = std::string, class BooleanType = bool, + class NumberIntegerType = std::int64_t, + class NumberUnsignedType = std::uint64_t, + class NumberFloatType = double, + template class AllocatorType = std::allocator, + template class JSONSerializer = + adl_serializer, + class BinaryType = std::vector, // cppcheck-suppress syntaxError + class CustomBaseClass = void> + class basic_json; + + /// @brief JSON Pointer defines a string syntax for identifying a specific value within a JSON document + /// @sa https://json.nlohmann.me/api/json_pointer/ + template + class json_pointer; + + /*! + @brief default specialization + @sa https://json.nlohmann.me/api/json/ + */ + using json = basic_json<>; + + /// @brief a minimal map-like container that preserves insertion order + /// @sa https://json.nlohmann.me/api/ordered_map/ + template + struct ordered_map; + + /// @brief specialization that maintains the insertion order of object keys + /// @sa https://json.nlohmann.me/api/ordered_json/ + using ordered_json = basic_json; + + NLOHMANN_JSON_NAMESPACE_END + +#endif // INCLUDE_NLOHMANN_JSON_FWD_HPP_ + + +NLOHMANN_JSON_NAMESPACE_BEGIN +/*! +@brief detail namespace with internal helper functions + +This namespace collects functions that should not be exposed, +implementations of some @ref basic_json methods, and meta-programming helpers. + +@since version 2.1.0 +*/ +namespace detail +{ + +///////////// +// helpers // +///////////// + +// Note to maintainers: +// +// Every trait in this file expects a non CV-qualified type. +// The only exceptions are in the 'aliases for detected' section +// (i.e. those of the form: decltype(T::member_function(std::declval()))) +// +// In this case, T has to be properly CV-qualified to constraint the function arguments +// (e.g. to_json(BasicJsonType&, const T&)) + +template struct is_basic_json : std::false_type {}; + +NLOHMANN_BASIC_JSON_TPL_DECLARATION +struct is_basic_json : std::true_type {}; + +// used by exceptions create() member functions +// true_type for pointer to possibly cv-qualified basic_json or std::nullptr_t +// false_type otherwise +template +struct is_basic_json_context : + std::integral_constant < bool, + is_basic_json::type>::type>::value + || std::is_same::value > +{}; + +////////////////////// +// json_ref helpers // +////////////////////// + +template +class json_ref; + +template +struct is_json_ref : std::false_type {}; + +template +struct is_json_ref> : std::true_type {}; + +////////////////////////// +// aliases for detected // +////////////////////////// + +template +using mapped_type_t = typename T::mapped_type; + +template +using key_type_t = typename T::key_type; + +template +using value_type_t = typename T::value_type; + +template +using difference_type_t = typename T::difference_type; + +template +using pointer_t = typename T::pointer; + +template +using reference_t = typename T::reference; + +template +using iterator_category_t = typename T::iterator_category; + +template +using to_json_function = decltype(T::to_json(std::declval()...)); + +template +using from_json_function = decltype(T::from_json(std::declval()...)); + +template +using get_template_function = decltype(std::declval().template get()); + +// trait checking if JSONSerializer::from_json(json const&, udt&) exists +template +struct has_from_json : std::false_type {}; + +// trait checking if j.get is valid +// use this trait instead of std::is_constructible or std::is_convertible, +// both rely on, or make use of implicit conversions, and thus fail when T +// has several constructors/operator= (see https://github.com/nlohmann/json/issues/958) +template +struct is_getable +{ + static constexpr bool value = is_detected::value; +}; + +template +struct has_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if JSONSerializer::from_json(json const&) exists +// this overload is used for non-default-constructible user-defined-types +template +struct has_non_default_from_json : std::false_type {}; + +template +struct has_non_default_from_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +// This trait checks if BasicJsonType::json_serializer::to_json exists +// Do not evaluate the trait when T is a basic_json type, to avoid template instantiation infinite recursion. +template +struct has_to_json : std::false_type {}; + +template +struct has_to_json < BasicJsonType, T, enable_if_t < !is_basic_json::value >> +{ + using serializer = typename BasicJsonType::template json_serializer; + + static constexpr bool value = + is_detected_exact::value; +}; + +template +using detect_key_compare = typename T::key_compare; + +template +struct has_key_compare : std::integral_constant::value> {}; + +// obtains the actual object key comparator +template +struct actual_object_comparator +{ + using object_t = typename BasicJsonType::object_t; + using object_comparator_t = typename BasicJsonType::default_object_comparator_t; + using type = typename std::conditional < has_key_compare::value, + typename object_t::key_compare, object_comparator_t>::type; +}; + +template +using actual_object_comparator_t = typename actual_object_comparator::type; + +///////////////// +// char_traits // +///////////////// + +// Primary template of char_traits calls std char_traits +template +struct char_traits : std::char_traits +{}; + +// Explicitly define char traits for unsigned char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = unsigned char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +// Explicitly define char traits for signed char since it is not standard +template<> +struct char_traits : std::char_traits +{ + using char_type = signed char; + using int_type = uint64_t; + + // Redefine to_int_type function + static int_type to_int_type(char_type c) noexcept + { + return static_cast(c); + } + + static char_type to_char_type(int_type i) noexcept + { + return static_cast(i); + } + + static constexpr int_type eof() noexcept + { + return static_cast(EOF); + } +}; + +/////////////////// +// is_ functions // +/////////////////// + +// https://en.cppreference.com/w/cpp/types/conjunction +template struct conjunction : std::true_type { }; +template struct conjunction : B { }; +template +struct conjunction +: std::conditional(B::value), conjunction, B>::type {}; + +// https://en.cppreference.com/w/cpp/types/negation +template struct negation : std::integral_constant < bool, !B::value > { }; + +// Reimplementation of is_constructible and is_default_constructible, due to them being broken for +// std::pair and std::tuple until LWG 2367 fix (see https://cplusplus.github.io/LWG/lwg-defects.html#2367). +// This causes compile errors in e.g. clang 3.5 or gcc 4.9. +template +struct is_default_constructible : std::is_default_constructible {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction, is_default_constructible> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_default_constructible> + : conjunction...> {}; + +template +struct is_constructible : std::is_constructible {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_constructible> : is_default_constructible> {}; + +template +struct is_iterator_traits : std::false_type {}; + +template +struct is_iterator_traits> +{ + private: + using traits = iterator_traits; + + public: + static constexpr auto value = + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value && + is_detected::value; +}; + +template +struct is_range +{ + private: + using t_ref = typename std::add_lvalue_reference::type; + + using iterator = detected_t; + using sentinel = detected_t; + + // to be 100% correct, it should use https://en.cppreference.com/w/cpp/iterator/input_or_output_iterator + // and https://en.cppreference.com/w/cpp/iterator/sentinel_for + // but reimplementing these would be too much work, as a lot of other concepts are used underneath + static constexpr auto is_iterator_begin = + is_iterator_traits>::value; + + public: + static constexpr bool value = !std::is_same::value && !std::is_same::value && is_iterator_begin; +}; + +template +using iterator_t = enable_if_t::value, result_of_begin())>>; + +template +using range_value_t = value_type_t>>; + +// The following implementation of is_complete_type is taken from +// https://blogs.msdn.microsoft.com/vcblog/2015/12/02/partial-support-for-expression-sfinae-in-vs-2015-update-1/ +// and is written by Xiang Fan who agreed to using it in this library. + +template +struct is_complete_type : std::false_type {}; + +template +struct is_complete_type : std::true_type {}; + +template +struct is_compatible_object_type_impl : std::false_type {}; + +template +struct is_compatible_object_type_impl < + BasicJsonType, CompatibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + // macOS's is_constructible does not play well with nonesuch... + static constexpr bool value = + is_constructible::value && + is_constructible::value; +}; + +template +struct is_compatible_object_type + : is_compatible_object_type_impl {}; + +template +struct is_constructible_object_type_impl : std::false_type {}; + +template +struct is_constructible_object_type_impl < + BasicJsonType, ConstructibleObjectType, + enable_if_t < is_detected::value&& + is_detected::value >> +{ + using object_t = typename BasicJsonType::object_t; + + static constexpr bool value = + (is_default_constructible::value && + (std::is_move_assignable::value || + std::is_copy_assignable::value) && + (is_constructible::value && + std::is_same < + typename object_t::mapped_type, + typename ConstructibleObjectType::mapped_type >::value)) || + (has_from_json::value || + has_non_default_from_json < + BasicJsonType, + typename ConstructibleObjectType::mapped_type >::value); +}; + +template +struct is_constructible_object_type + : is_constructible_object_type_impl {}; + +template +struct is_compatible_string_type +{ + static constexpr auto value = + is_constructible::value; +}; + +template +struct is_constructible_string_type +{ + // launder type through decltype() to fix compilation failure on ICPC +#ifdef __INTEL_COMPILER + using laundered_type = decltype(std::declval()); +#else + using laundered_type = ConstructibleStringType; +#endif + + static constexpr auto value = + conjunction < + is_constructible, + is_detected_exact>::value; +}; + +template +struct is_compatible_array_type_impl : std::false_type {}; + +template +struct is_compatible_array_type_impl < + BasicJsonType, CompatibleArrayType, + enable_if_t < + is_detected::value&& + is_iterator_traits>>::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 + !std::is_same>::value >> +{ + static constexpr bool value = + is_constructible>::value; +}; + +template +struct is_compatible_array_type + : is_compatible_array_type_impl {}; + +template +struct is_constructible_array_type_impl : std::false_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t::value >> + : std::true_type {}; + +template +struct is_constructible_array_type_impl < + BasicJsonType, ConstructibleArrayType, + enable_if_t < !std::is_same::value&& + !is_compatible_string_type::value&& + is_default_constructible::value&& +(std::is_move_assignable::value || + std::is_copy_assignable::value)&& +is_detected::value&& +is_iterator_traits>>::value&& +is_detected::value&& +// special case for types like std::filesystem::path whose iterator's value_type are themselves +// c.f. https://github.com/nlohmann/json/pull/3073 +!std::is_same>::value&& + is_complete_type < + detected_t>::value >> +{ + using value_type = range_value_t; + + static constexpr bool value = + std::is_same::value || + has_from_json::value || + has_non_default_from_json < + BasicJsonType, + value_type >::value; +}; + +template +struct is_constructible_array_type + : is_constructible_array_type_impl {}; + +template +struct is_compatible_integer_type_impl : std::false_type {}; + +template +struct is_compatible_integer_type_impl < + RealIntegerType, CompatibleNumberIntegerType, + enable_if_t < std::is_integral::value&& + std::is_integral::value&& + !std::is_same::value >> +{ + // is there an assert somewhere on overflows? + using RealLimits = std::numeric_limits; + using CompatibleLimits = std::numeric_limits; + + static constexpr auto value = + is_constructible::value && + CompatibleLimits::is_integer && + RealLimits::is_signed == CompatibleLimits::is_signed; +}; + +template +struct is_compatible_integer_type + : is_compatible_integer_type_impl {}; + +template +struct is_compatible_type_impl: std::false_type {}; + +template +struct is_compatible_type_impl < + BasicJsonType, CompatibleType, + enable_if_t::value >> +{ + static constexpr bool value = + has_to_json::value; +}; + +template +struct is_compatible_type + : is_compatible_type_impl {}; + +template +struct is_constructible_tuple : std::false_type {}; + +template +struct is_constructible_tuple> : conjunction...> {}; + +template +struct is_json_iterator_of : std::false_type {}; + +template +struct is_json_iterator_of : std::true_type {}; + +template +struct is_json_iterator_of : std::true_type +{}; + +// checks if a given type T is a template specialization of Primary +template