| #!/usr/bin/env python3 | |
| import re | |
| import sys | |
| import pprint | |
| import getopt | |
| pp = pprint.PrettyPrinter(indent=4) | |
| prefix = None | |
| pmgfiles = list() | |
| outfile = None | |
| debug = False | |
| genhdr = False | |
| opts, args = getopt.getopt(sys.argv[1:], "p:o:dg") | |
| for o, a in opts: | |
| if o == "-p": | |
| prefix = a | |
| elif o == "-o": | |
| outfile = a | |
| elif o == "-d": | |
| debug = True | |
| elif o == "-g": | |
| genhdr = True | |
| if outfile is None: | |
| outfile = "/dev/stdout" | |
| for a in args: | |
| assert a.endswith(".pmg") | |
| if prefix is None and len(args) == 1: | |
| prefix = a[0:-4] | |
| prefix = prefix.split('/')[-1] | |
| pmgfiles.append(a) | |
| assert prefix is not None | |
| current_pattern = None | |
| current_subpattern = None | |
| patterns = dict() | |
| subpatterns = dict() | |
| subpattern_args = dict() | |
| state_types = dict() | |
| udata_types = dict() | |
| blocks = list() | |
| ids = dict() | |
| def rewrite_cpp(s): | |
| t = list() | |
| i = 0 | |
| while i < len(s): | |
| if s[i] in ("'", '"') and i + 1 < len(s): | |
| j = i + 1 | |
| while j + 1 < len(s) and s[j] != s[i]: | |
| if s[j] == '\\' and j + 1 < len(s): | |
| j += 1 | |
| j += 1 | |
| t.append(s[i:j+1]) | |
| i = j + 1 | |
| continue | |
| if s[i] in ('$', '\\') and i + 1 < len(s): | |
| j = i + 1 | |
| while True: | |
| if j == len(s): | |
| j -= 1 | |
| break | |
| if ord('a') <= ord(s[j]) <= ord('z'): | |
| j += 1 | |
| continue | |
| if ord('A') <= ord(s[j]) <= ord('Z'): | |
| j += 1 | |
| continue | |
| if ord('0') <= ord(s[j]) <= ord('9'): | |
| j += 1 | |
| continue | |
| if s[j] == '_': | |
| j += 1 | |
| continue | |
| j -= 1 | |
| break | |
| n = s[i:j+1] | |
| i = j + 1 | |
| if n[0] == '$': | |
| v = "id_d_" + n[1:] | |
| else: | |
| v = "id_b_" + n[1:] | |
| if v not in ids: | |
| ids[v] = n | |
| else: | |
| assert ids[v] == n | |
| t.append(v) | |
| continue | |
| if s[i] == "\t": | |
| t.append(" ") | |
| else: | |
| t.append(s[i]) | |
| i += 1 | |
| return "".join(t) | |
| def process_pmgfile(f, filename): | |
| linenr = 0 | |
| global current_pattern | |
| global current_subpattern | |
| while True: | |
| linenr += 1 | |
| line = f.readline() | |
| if line == "": break | |
| line = line.strip() | |
| cmd = line.split() | |
| if len(cmd) == 0 or cmd[0].startswith("//"): continue | |
| cmd = cmd[0] | |
| if cmd == "pattern": | |
| if current_pattern is not None: | |
| block = dict() | |
| block["type"] = "final" | |
| block["pattern"] = (current_pattern, current_subpattern) | |
| blocks.append(block) | |
| line = line.split() | |
| assert len(line) == 2 | |
| assert line[1] not in patterns | |
| current_pattern = line[1] | |
| current_subpattern = "" | |
| patterns[current_pattern] = len(blocks) | |
| subpatterns[(current_pattern, current_subpattern)] = len(blocks) | |
| subpattern_args[(current_pattern, current_subpattern)] = list() | |
| state_types[current_pattern] = dict() | |
| udata_types[current_pattern] = dict() | |
| continue | |
| assert current_pattern is not None | |
| if cmd == "fallthrough": | |
| block = dict() | |
| block["type"] = "fallthrough" | |
| blocks.append(block) | |
| line = line.split() | |
| assert len(line) == 1 | |
| continue | |
| if cmd == "subpattern": | |
| if len(blocks) == 0 or blocks[-1]["type"] != "fallthrough": | |
| block = dict() | |
| block["type"] = "final" | |
| block["pattern"] = (current_pattern, current_subpattern) | |
| blocks.append(block) | |
| elif len(blocks) and blocks[-1]["type"] == "fallthrough": | |
| del blocks[-1] | |
| line = line.split() | |
| assert len(line) == 2 | |
| current_subpattern = line[1] | |
| subpattern_args[(current_pattern, current_subpattern)] = list() | |
| assert (current_pattern, current_subpattern) not in subpatterns | |
| subpatterns[(current_pattern, current_subpattern)] = len(blocks) | |
| continue | |
| if cmd == "arg": | |
| line = line.split() | |
| assert len(line) > 1 | |
| subpattern_args[(current_pattern, current_subpattern)] += line[1:] | |
| continue | |
| if cmd == "state": | |
| m = re.match(r"^state\s+<(.*?)>\s+(([A-Za-z_][A-Za-z_0-9]*\s+)*[A-Za-z_][A-Za-z_0-9]*)\s*$", line) | |
| assert m | |
| type_str = m.group(1) | |
| states_str = m.group(2) | |
| for s in re.split(r"\s+", states_str): | |
| assert s not in state_types[current_pattern] | |
| state_types[current_pattern][s] = type_str | |
| continue | |
| if cmd == "udata": | |
| m = re.match(r"^udata\s+<(.*?)>\s+(([A-Za-z_][A-Za-z_0-9]*\s+)*[A-Za-z_][A-Za-z_0-9]*)\s*$", line) | |
| assert m | |
| type_str = m.group(1) | |
| udatas_str = m.group(2) | |
| for s in re.split(r"\s+", udatas_str): | |
| assert s not in udata_types[current_pattern] | |
| udata_types[current_pattern][s] = type_str | |
| continue | |
| if cmd == "match": | |
| block = dict() | |
| block["type"] = "match" | |
| block["src"] = "%s:%d" % (filename, linenr) | |
| block["pattern"] = (current_pattern, current_subpattern) | |
| block["genargs"] = None | |
| block["gencode"] = None | |
| line = line.split() | |
| assert len(line) == 2 | |
| assert (line[1] not in state_types[current_pattern]) or (state_types[current_pattern][line[1]] == "Cell*") | |
| block["cell"] = line[1] | |
| state_types[current_pattern][line[1]] = "Cell*"; | |
| block["if"] = list() | |
| block["setup"] = list() | |
| block["index"] = list() | |
| block["filter"] = list() | |
| block["sets"] = list() | |
| block["optional"] = False | |
| block["semioptional"] = False | |
| while True: | |
| linenr += 1 | |
| l = f.readline() | |
| assert l != "" | |
| a = l.split() | |
| if len(a) == 0 or a[0].startswith("//"): continue | |
| if a[0] == "endmatch": break | |
| if a[0] == "if": | |
| b = l.lstrip()[2:] | |
| block["if"].append(rewrite_cpp(b.strip())) | |
| continue | |
| if a[0] == "select": | |
| b = l.lstrip()[6:] | |
| block["setup"].append(("select", rewrite_cpp(b.strip()))) | |
| continue | |
| if a[0] == "slice": | |
| m = re.match(r"^\s*slice\s+(\S+)\s+(.*?)\s*$", l) | |
| block["setup"].append(("slice", m.group(1), rewrite_cpp(m.group(2)))) | |
| continue | |
| if a[0] == "choice": | |
| m = re.match(r"^\s*choice\s+<(.*?)>\s+(\S+)\s+(.*?)\s*$", l) | |
| block["setup"].append(("choice", m.group(1), m.group(2), rewrite_cpp(m.group(3)))) | |
| continue | |
| if a[0] == "define": | |
| m = re.match(r"^\s*define\s+<(.*?)>\s+(\S+)\s+(.*?)\s*$", l) | |
| block["setup"].append(("define", m.group(1), m.group(2), rewrite_cpp(m.group(3)))) | |
| continue | |
| if a[0] == "index": | |
| m = re.match(r"^\s*index\s+<(.*?)>\s+(.*?)\s*===\s*(.*?)\s*$", l) | |
| assert m | |
| block["index"].append((m.group(1), rewrite_cpp(m.group(2)), rewrite_cpp(m.group(3)))) | |
| continue | |
| if a[0] == "filter": | |
| b = l.lstrip()[6:] | |
| block["filter"].append(rewrite_cpp(b.strip())) | |
| continue | |
| if a[0] == "set": | |
| m = re.match(r"^\s*set\s+(\S+)\s+(.*?)\s*$", l) | |
| block["sets"].append((m.group(1), rewrite_cpp(m.group(2)))) | |
| continue | |
| if a[0] == "optional": | |
| block["optional"] = True | |
| continue | |
| if a[0] == "semioptional": | |
| block["semioptional"] = True | |
| continue | |
| if a[0] == "generate": | |
| block["genargs"] = list([int(s) for s in a[1:]]) | |
| if len(block["genargs"]) == 0: block["genargs"].append(100) | |
| if len(block["genargs"]) == 1: block["genargs"].append(0) | |
| assert len(block["genargs"]) == 2 | |
| block["gencode"] = list() | |
| while True: | |
| linenr += 1 | |
| l = f.readline() | |
| assert l != "" | |
| a = l.split() | |
| if len(a) == 1 and a[0] == "endmatch": break | |
| block["gencode"].append(rewrite_cpp(l.rstrip())) | |
| break | |
| raise RuntimeError("'%s' statement not recognised on line %d" % (a[0], linenr)) | |
| if block["optional"]: | |
| assert not block["semioptional"] | |
| blocks.append(block) | |
| continue | |
| if cmd == "code": | |
| block = dict() | |
| block["type"] = "code" | |
| block["src"] = "%s:%d" % (filename, linenr) | |
| block["pattern"] = (current_pattern, current_subpattern) | |
| block["code"] = list() | |
| block["fcode"] = list() | |
| block["states"] = set() | |
| for s in line.split()[1:]: | |
| if s not in state_types[current_pattern]: | |
| raise RuntimeError("'%s' not in state_types" % s) | |
| block["states"].add(s) | |
| codetype = "code" | |
| while True: | |
| linenr += 1 | |
| l = f.readline() | |
| assert l != "" | |
| a = l.split() | |
| if len(a) == 0: continue | |
| if a[0] == "endcode": break | |
| if a[0] == "finally": | |
| codetype = "fcode" | |
| continue | |
| block[codetype].append(rewrite_cpp(l.rstrip())) | |
| blocks.append(block) | |
| continue | |
| raise RuntimeError("'%s' command not recognised" % cmd) | |
| for fn in pmgfiles: | |
| with open(fn, "r") as f: | |
| process_pmgfile(f, fn) | |
| if current_pattern is not None: | |
| block = dict() | |
| block["type"] = "final" | |
| block["pattern"] = (current_pattern, current_subpattern) | |
| blocks.append(block) | |
| current_pattern = None | |
| current_subpattern = None | |
| if debug: | |
| pp.pprint(blocks) | |
| with open(outfile, "w") as f: | |
| for fn in pmgfiles: | |
| print("// Generated by pmgen.py from {}".format(fn), file=f) | |
| print("", file=f) | |
| if genhdr: | |
| print("#include \"kernel/yosys.h\"", file=f) | |
| print("#include \"kernel/sigtools.h\"", file=f) | |
| print("", file=f) | |
| print("YOSYS_NAMESPACE_BEGIN", file=f) | |
| print("", file=f) | |
| print("struct {}_pm {{".format(prefix), file=f) | |
| print(" Module *module;", file=f) | |
| print(" SigMap sigmap;", file=f) | |
| print(" std::function<void()> on_accept;", file=f) | |
| print(" bool setup_done;", file=f) | |
| print(" bool generate_mode;", file=f) | |
| print(" int accept_cnt;", file=f) | |
| print("", file=f) | |
| print(" uint32_t rngseed;", file=f) | |
| print(" int rng(unsigned int n) {", file=f) | |
| print(" rngseed ^= rngseed << 13;", file=f) | |
| print(" rngseed ^= rngseed >> 17;", file=f) | |
| print(" rngseed ^= rngseed << 5;", file=f) | |
| print(" return rngseed % n;", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| for index in range(len(blocks)): | |
| block = blocks[index] | |
| if block["type"] == "match": | |
| index_types = list() | |
| for entry in block["index"]: | |
| index_types.append(entry[0]) | |
| value_types = ["Cell*"] | |
| for entry in block["setup"]: | |
| if entry[0] == "slice": | |
| value_types.append("int") | |
| if entry[0] == "choice": | |
| value_types.append(entry[1]) | |
| if entry[0] == "define": | |
| value_types.append(entry[1]) | |
| print(" typedef std::tuple<{}> index_{}_key_type;".format(", ".join(index_types), index), file=f) | |
| print(" typedef std::tuple<{}> index_{}_value_type;".format(", ".join(value_types), index), file=f) | |
| print(" dict<index_{}_key_type, vector<index_{}_value_type>> index_{};".format(index, index, index), file=f) | |
| print(" dict<SigBit, pool<Cell*>> sigusers;", file=f) | |
| print(" pool<Cell*> blacklist_cells;", file=f) | |
| print(" pool<Cell*> autoremove_cells;", file=f) | |
| print(" dict<Cell*,int> rollback_cache;", file=f) | |
| print(" int rollback;", file=f) | |
| print("", file=f) | |
| for current_pattern in sorted(patterns.keys()): | |
| print(" struct state_{}_t {{".format(current_pattern), file=f) | |
| for s, t in sorted(state_types[current_pattern].items()): | |
| print(" {} {};".format(t, s), file=f) | |
| print(" }} st_{};".format(current_pattern), file=f) | |
| print("", file=f) | |
| print(" struct udata_{}_t {{".format(current_pattern), file=f) | |
| for s, t in sorted(udata_types[current_pattern].items()): | |
| print(" {} {};".format(t, s), file=f) | |
| print(" }} ud_{};".format(current_pattern), file=f) | |
| print("", file=f) | |
| current_pattern = None | |
| for v, n in sorted(ids.items()): | |
| if n[0] == "\\": | |
| print(" IdString {}{{\"\\{}\"}};".format(v, n), file=f) | |
| else: | |
| print(" IdString {}{{\"{}\"}};".format(v, n), file=f) | |
| print("", file=f) | |
| print(" void add_siguser(const SigSpec &sig, Cell *cell) {", file=f) | |
| print(" for (auto bit : sigmap(sig)) {", file=f) | |
| print(" if (bit.wire == nullptr) continue;", file=f) | |
| print(" sigusers[bit].insert(cell);", file=f) | |
| print(" }", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" void blacklist(Cell *cell) {", file=f) | |
| print(" if (cell != nullptr && blacklist_cells.insert(cell).second) {", file=f) | |
| print(" auto ptr = rollback_cache.find(cell);", file=f) | |
| print(" if (ptr == rollback_cache.end()) return;", file=f) | |
| print(" int rb = ptr->second;", file=f) | |
| print(" if (rollback == 0 || rollback > rb)", file=f) | |
| print(" rollback = rb;", file=f) | |
| print(" }", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" void autoremove(Cell *cell) {", file=f) | |
| print(" if (cell != nullptr) {", file=f) | |
| print(" autoremove_cells.insert(cell);", file=f) | |
| print(" blacklist(cell);", file=f) | |
| print(" }", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| current_pattern = None | |
| print(" SigSpec port(Cell *cell, IdString portname) {", file=f) | |
| print(" return sigmap(cell->getPort(portname));", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" SigSpec port(Cell *cell, IdString portname, const SigSpec& defval) {", file=f) | |
| print(" return sigmap(cell->connections_.at(portname, defval));", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" Const param(Cell *cell, IdString paramname) {", file=f) | |
| print(" return cell->getParam(paramname);", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" Const param(Cell *cell, IdString paramname, const Const& defval) {", file=f) | |
| print(" return cell->parameters.at(paramname, defval);", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" int nusers(const SigSpec &sig) {", file=f) | |
| print(" pool<Cell*> users;", file=f) | |
| print(" for (auto bit : sigmap(sig))", file=f) | |
| print(" for (auto user : sigusers[bit])", file=f) | |
| print(" users.insert(user);", file=f) | |
| print(" return GetSize(users);", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" {}_pm(Module *module, const vector<Cell*> &cells) :".format(prefix), file=f) | |
| print(" module(module), sigmap(module), setup_done(false), generate_mode(false), rngseed(12345678) {", file=f) | |
| print(" setup(cells);", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" {}_pm(Module *module) :".format(prefix), file=f) | |
| print(" module(module), sigmap(module), setup_done(false), generate_mode(false), rngseed(12345678) {", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" void setup(const vector<Cell*> &cells) {", file=f) | |
| for current_pattern in sorted(patterns.keys()): | |
| for s, t in sorted(udata_types[current_pattern].items()): | |
| if t.endswith("*"): | |
| print(" ud_{}.{} = nullptr;".format(current_pattern,s), file=f) | |
| else: | |
| print(" ud_{}.{} = {}();".format(current_pattern, s, t), file=f) | |
| current_pattern = None | |
| print(" log_assert(!setup_done);", file=f) | |
| print(" setup_done = true;", file=f) | |
| print(" for (auto port : module->ports)", file=f) | |
| print(" add_siguser(module->wire(port), nullptr);", file=f) | |
| print(" for (auto cell : module->cells())", file=f) | |
| print(" for (auto &conn : cell->connections())", file=f) | |
| print(" add_siguser(conn.second, cell);", file=f) | |
| print(" for (auto cell : cells) {", file=f) | |
| for index in range(len(blocks)): | |
| block = blocks[index] | |
| if block["type"] == "match": | |
| print(" do {", file=f) | |
| print(" Cell *{} = cell;".format(block["cell"]), file=f) | |
| print(" index_{}_value_type value;".format(index), file=f) | |
| print(" std::get<0>(value) = cell;", file=f) | |
| loopcnt = 0 | |
| valueidx = 1 | |
| for item in block["setup"]: | |
| if item[0] == "select": | |
| print(" if (!({})) continue;".format(item[1]), file=f) | |
| if item[0] == "slice": | |
| print(" int &{} = std::get<{}>(value);".format(item[1], valueidx), file=f) | |
| print(" for ({} = 0; {} < {}; {}++) {{".format(item[1], item[1], item[2], item[1]), file=f) | |
| valueidx += 1 | |
| loopcnt += 1 | |
| if item[0] == "choice": | |
| print(" vector<{}> _pmg_choices_{} = {};".format(item[1], item[2], item[3]), file=f) | |
| print(" for (const {} &{} : _pmg_choices_{}) {{".format(item[1], item[2], item[2]), file=f) | |
| print(" std::get<{}>(value) = {};".format(valueidx, item[2]), file=f) | |
| valueidx += 1 | |
| loopcnt += 1 | |
| if item[0] == "define": | |
| print(" {} &{} = std::get<{}>(value);".format(item[1], item[2], valueidx), file=f) | |
| print(" {} = {};".format(item[2], item[3]), file=f) | |
| valueidx += 1 | |
| print(" index_{}_key_type key;".format(index), file=f) | |
| for field, entry in enumerate(block["index"]): | |
| print(" std::get<{}>(key) = {};".format(field, entry[1]), file=f) | |
| print(" index_{}[key].push_back(value);".format(index), file=f) | |
| for i in range(loopcnt): | |
| print(" }", file=f) | |
| print(" } while (0);", file=f) | |
| print(" }", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" ~{}_pm() {{".format(prefix), file=f) | |
| print(" for (auto cell : autoremove_cells)", file=f) | |
| print(" module->remove(cell);", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| for current_pattern in sorted(patterns.keys()): | |
| print(" int run_{}(std::function<void()> on_accept_f) {{".format(current_pattern), file=f) | |
| print(" log_assert(setup_done);", file=f) | |
| print(" accept_cnt = 0;", file=f) | |
| print(" on_accept = on_accept_f;", file=f) | |
| print(" rollback = 0;", file=f) | |
| for s, t in sorted(state_types[current_pattern].items()): | |
| if t.endswith("*"): | |
| print(" st_{}.{} = nullptr;".format(current_pattern, s), file=f) | |
| else: | |
| print(" st_{}.{} = {}();".format(current_pattern, s, t), file=f) | |
| print(" block_{}(1);".format(patterns[current_pattern]), file=f) | |
| print(" log_assert(rollback_cache.empty());", file=f) | |
| print(" return accept_cnt;", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" int run_{}(std::function<void({}_pm&)> on_accept_f) {{".format(current_pattern, prefix), file=f) | |
| print(" return run_{}([&](){{on_accept_f(*this);}});".format(current_pattern), file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" int run_{}() {{".format(current_pattern), file=f) | |
| print(" return run_{}([](){{}});".format(current_pattern, current_pattern), file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| if len(subpatterns): | |
| for p, s in sorted(subpatterns.keys()): | |
| print(" void block_subpattern_{}_{}(int recursion) {{ block_{}(recursion); }}".format(p, s, subpatterns[(p, s)]), file=f) | |
| print("", file=f) | |
| current_pattern = None | |
| current_subpattern = None | |
| for index in range(len(blocks)): | |
| block = blocks[index] | |
| if block["type"] in ("match", "code"): | |
| print(" // {}".format(block["src"]), file=f) | |
| print(" void block_{}(int recursion YS_ATTRIBUTE(unused)) {{".format(index), file=f) | |
| current_pattern, current_subpattern = block["pattern"] | |
| if block["type"] == "final": | |
| print(" }", file=f) | |
| if index+1 != len(blocks): | |
| print("", file=f) | |
| continue | |
| const_st = set() | |
| nonconst_st = set() | |
| restore_st = set() | |
| for s in subpattern_args[(current_pattern, current_subpattern)]: | |
| const_st.add(s) | |
| for i in range(subpatterns[(current_pattern, current_subpattern)], index): | |
| if blocks[i]["type"] == "code": | |
| for s in blocks[i]["states"]: | |
| const_st.add(s) | |
| elif blocks[i]["type"] == "match": | |
| const_st.add(blocks[i]["cell"]) | |
| for item in blocks[i]["sets"]: | |
| const_st.add(item[0]) | |
| else: | |
| assert False | |
| if block["type"] == "code": | |
| for s in block["states"]: | |
| if s in const_st: | |
| const_st.remove(s) | |
| restore_st.add(s) | |
| nonconst_st.add(s) | |
| elif block["type"] == "match": | |
| s = block["cell"] | |
| assert s not in const_st | |
| nonconst_st.add(s) | |
| for item in block["sets"]: | |
| if item[0] in const_st: | |
| const_st.remove(item[0]) | |
| nonconst_st.add(item[0]) | |
| else: | |
| assert False | |
| for s in sorted(const_st): | |
| t = state_types[current_pattern][s] | |
| if t.endswith("*"): | |
| print(" {} const &{} YS_ATTRIBUTE(unused) = st_{}.{};".format(t, s, current_pattern, s), file=f) | |
| else: | |
| print(" const {} &{} YS_ATTRIBUTE(unused) = st_{}.{};".format(t, s, current_pattern, s), file=f) | |
| for s in sorted(nonconst_st): | |
| t = state_types[current_pattern][s] | |
| print(" {} &{} YS_ATTRIBUTE(unused) = st_{}.{};".format(t, s, current_pattern, s), file=f) | |
| for u in sorted(udata_types[current_pattern].keys()): | |
| t = udata_types[current_pattern][u] | |
| print(" {} &{} YS_ATTRIBUTE(unused) = ud_{}.{};".format(t, u, current_pattern, u), file=f) | |
| if len(restore_st): | |
| print("", file=f) | |
| for s in sorted(restore_st): | |
| t = state_types[current_pattern][s] | |
| print(" {} _pmg_backup_{} = {};".format(t, s, s), file=f) | |
| if block["type"] == "code": | |
| print("", file=f) | |
| print("#define reject do { goto rollback_label; } while(0)", file=f) | |
| print("#define accept do { accept_cnt++; on_accept(); if (rollback) goto rollback_label; } while(0)", file=f) | |
| print("#define finish do { rollback = -1; goto rollback_label; } while(0)", file=f) | |
| print("#define branch do {{ block_{}(recursion+1); if (rollback) goto rollback_label; }} while(0)".format(index+1), file=f) | |
| print("#define subpattern(pattern_name) do {{ block_subpattern_{}_ ## pattern_name (recursion+1); if (rollback) goto rollback_label; }} while(0)".format(current_pattern), file=f) | |
| for line in block["code"]: | |
| print(" " + line, file=f) | |
| print("", file=f) | |
| print(" block_{}(recursion+1);".format(index+1), file=f) | |
| print("#undef reject", file=f) | |
| print("#undef accept", file=f) | |
| print("#undef finish", file=f) | |
| print("#undef branch", file=f) | |
| print("#undef subpattern", file=f) | |
| print("", file=f) | |
| print("rollback_label:", file=f) | |
| print(" YS_ATTRIBUTE(unused);", file=f) | |
| if len(block["fcode"]): | |
| print("#define accept do { accept_cnt++; on_accept(); } while(0)", file=f) | |
| print("#define finish do { rollback = -1; goto finish_label; } while(0)", file=f) | |
| for line in block["fcode"]: | |
| print(" " + line, file=f) | |
| print("finish_label:", file=f) | |
| print(" YS_ATTRIBUTE(unused);", file=f) | |
| print("#undef accept", file=f) | |
| print("#undef finish", file=f) | |
| if len(restore_st) or len(nonconst_st): | |
| print("", file=f) | |
| for s in sorted(restore_st): | |
| t = state_types[current_pattern][s] | |
| print(" {} = _pmg_backup_{};".format(s, s), file=f) | |
| for s in sorted(nonconst_st): | |
| if s not in restore_st: | |
| t = state_types[current_pattern][s] | |
| if t.endswith("*"): | |
| print(" {} = nullptr;".format(s), file=f) | |
| else: | |
| print(" {} = {}();".format(s, t), file=f) | |
| elif block["type"] == "match": | |
| assert len(restore_st) == 0 | |
| print(" Cell* _pmg_backup_{} = {};".format(block["cell"], block["cell"]), file=f) | |
| if len(block["if"]): | |
| for expr in block["if"]: | |
| print("", file=f) | |
| print(" if (!({})) {{".format(expr), file=f) | |
| print(" {} = nullptr;".format(block["cell"]), file=f) | |
| print(" block_{}(recursion+1);".format(index+1), file=f) | |
| print(" {} = _pmg_backup_{};".format(block["cell"], block["cell"]), file=f) | |
| print(" return;", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" index_{}_key_type key;".format(index), file=f) | |
| for field, entry in enumerate(block["index"]): | |
| print(" std::get<{}>(key) = {};".format(field, entry[2]), file=f) | |
| print(" auto cells_ptr = index_{}.find(key);".format(index), file=f) | |
| if block["semioptional"] or block["genargs"] is not None: | |
| print(" bool found_any_match = false;", file=f) | |
| print("", file=f) | |
| print(" if (cells_ptr != index_{}.end()) {{".format(index), file=f) | |
| print(" const vector<index_{}_value_type> &cells = cells_ptr->second;".format(index), file=f) | |
| print(" for (int _pmg_idx = 0; _pmg_idx < GetSize(cells); _pmg_idx++) {", file=f) | |
| print(" {} = std::get<0>(cells[_pmg_idx]);".format(block["cell"]), file=f) | |
| valueidx = 1 | |
| for item in block["setup"]: | |
| if item[0] == "slice": | |
| print(" const int &{} YS_ATTRIBUTE(unused) = std::get<{}>(cells[_pmg_idx]);".format(item[1], valueidx), file=f) | |
| valueidx += 1 | |
| if item[0] == "choice": | |
| print(" const {} &{} YS_ATTRIBUTE(unused) = std::get<{}>(cells[_pmg_idx]);".format(item[1], item[2], valueidx), file=f) | |
| valueidx += 1 | |
| if item[0] == "define": | |
| print(" const {} &{} YS_ATTRIBUTE(unused) = std::get<{}>(cells[_pmg_idx]);".format(item[1], item[2], valueidx), file=f) | |
| valueidx += 1 | |
| print(" if (blacklist_cells.count({})) continue;".format(block["cell"]), file=f) | |
| for expr in block["filter"]: | |
| print(" if (!({})) continue;".format(expr), file=f) | |
| if block["semioptional"] or block["genargs"] is not None: | |
| print(" found_any_match = true;", file=f) | |
| for item in block["sets"]: | |
| print(" auto _pmg_backup_{} = {};".format(item[0], item[0]), file=f) | |
| print(" {} = {};".format(item[0], item[1]), file=f) | |
| print(" auto rollback_ptr = rollback_cache.insert(make_pair(std::get<0>(cells[_pmg_idx]), recursion));", file=f) | |
| print(" block_{}(recursion+1);".format(index+1), file=f) | |
| for item in block["sets"]: | |
| print(" {} = _pmg_backup_{};".format(item[0], item[0]), file=f) | |
| print(" if (rollback_ptr.second)", file=f) | |
| print(" rollback_cache.erase(rollback_ptr.first);", file=f) | |
| print(" if (rollback) {", file=f) | |
| print(" if (rollback != recursion) {{".format(index+1), file=f) | |
| print(" {} = _pmg_backup_{};".format(block["cell"], block["cell"]), file=f) | |
| print(" return;", file=f) | |
| print(" }", file=f) | |
| print(" rollback = 0;", file=f) | |
| print(" }", file=f) | |
| print(" }", file=f) | |
| print(" }", file=f) | |
| print("", file=f) | |
| print(" {} = nullptr;".format(block["cell"]), file=f) | |
| if block["optional"]: | |
| print(" block_{}(recursion+1);".format(index+1), file=f) | |
| if block["semioptional"]: | |
| print(" if (!found_any_match) block_{}(recursion+1);".format(index+1), file=f) | |
| print(" {} = _pmg_backup_{};".format(block["cell"], block["cell"]), file=f) | |
| if block["genargs"] is not None: | |
| print("#define finish do { rollback = -1; return; } while(0)", file=f) | |
| print(" if (generate_mode && rng(100) < (found_any_match ? {} : {})) {{".format(block["genargs"][1], block["genargs"][0]), file=f) | |
| for line in block["gencode"]: | |
| print(" " + line, file=f) | |
| print(" }", file=f) | |
| print("#undef finish", file=f) | |
| else: | |
| assert False | |
| current_pattern = None | |
| print(" }", file=f) | |
| print("", file=f) | |
| print("};", file=f) | |
| if genhdr: | |
| print("", file=f) | |
| print("YOSYS_NAMESPACE_END", file=f) |