srvn_writer.h

Go to the documentation of this file.

/*
 * Copyright (c) 2012-2026, QORE Lab, Imperial College London
 * All rights reserved.
 */
#ifndef LINE_LANG_LQN_SRVN_WRITER_H
#define LINE_LANG_LQN_SRVN_WRITER_H
 
/**
 * @file
 * @ingroup line_lang
 * SRVN output (the LQNS `.in` text grammar) for layered models, the C++ twin of
 * `lqnx2srvn` / `srvn_save` in python/line_solver/io/srvn_io.py.
 *
 * The writer is the reader's inverse: an LQN XML document goes to SRVN text, so
 * `write_srvn` is `write_lqnx` followed by `lqnx2srvn`, and the mapping of a
 * model onto the LQN schema stays in one place. The output is deterministic and
 * byte-identical across the four codebases (`srvn/expected_srvn` golden in
 * line-test.git). What SRVN cannot say is refused by name
 * (`LINE:unsupported:Format`) rather than dropped: an LQX program, SPEX
 * parameters, a semaphore's initial state, the LINE dialect elements (cache,
 * setup, call groups), and names that are not LQNS identifiers. Requests for
 * output (results, histograms, mva-info) are skipped, as the reader skips them.
 * Entry phases carry no activity names in SRVN, so a phase activity reads back
 * as `<entry>_<phase>`.
 *
 * The XML is read with `xml::parse`, then brought to what Python's ElementTree
 * (expat) hands the reference: attribute whitespace normalized to spaces and
 * numeric character references expanded. Malformed XML is `LINE:input:Format`;
 * its message is this parser's, not expat's.
 */
 
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <utility>
#include <vector>
 
#include "line/lang/lqn/lqn_writer.h"
#include "line/lang/lqn/srvn_reader.h"
#include "line/util/error.h"
#include "line/util/xml.h"
 
namespace line {
namespace lqn {
 
namespace srvn_out {
 
using xml::Element;
 
inline UnsupportedError unsup(const std::string& msg) {
    return UnsupportedError(ErrorKind{"Format"}, "SRVN output: " + msg);
}
 
inline InputError xerr(const std::string& msg) { return InputError(ErrorKind{"Format"}, "SRVN output: " + msg); }
 
/** `el.get(key)`, with Python's None as a null pointer. */
inline const std::string* get(const Element* el, const std::string& key) {
    for (const auto& kv : el->attrs)
        if (kv.first == key) return &kv.second;
    return NULL;
}
 
/** `el.get(key, dflt)`. */
inline std::string get(const Element* el, const std::string& key, const std::string& dflt) {
    const std::string* v = get(el, key);
    return v ? *v : dflt;
}
 
/** `'%s' % el.get(key)`: None prints as "None". */
inline std::string show(const Element* el, const std::string& key) {
    const std::string* v = get(el, key);
    return v ? *v : std::string("None");
}
 
inline std::string lower(std::string s) {
    for (char& c : s)
        if (c >= 'A' && c <= 'Z') c = static_cast<char>(c - 'A' + 'a');
    return s;
}
 
inline std::string upper(std::string s) {
    for (char& c : s)
        if (c >= 'a' && c <= 'z') c = static_cast<char>(c - 'a' + 'A');
    return s;
}
 
inline bool starts_with(const std::string& s, const char* p) { return s.compare(0, std::string(p).size(), p) == 0; }
 
inline void utf8(std::string& out, unsigned long cp) {
    if (cp < 0x80) out += static_cast<char>(cp);
    else if (cp < 0x800) {
        out += static_cast<char>(0xC0 | (cp >> 6));
        out += static_cast<char>(0x80 | (cp & 0x3F));
    } else if (cp < 0x10000) {
        out += static_cast<char>(0xE0 | (cp >> 12));
        out += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
        out += static_cast<char>(0x80 | (cp & 0x3F));
    } else {
        out += static_cast<char>(0xF0 | (cp >> 18));
        out += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
        out += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
        out += static_cast<char>(0x80 | (cp & 0x3F));
    }
}
 
/**
 * An attribute value as expat delivers it: literal tab, CR and LF become spaces
 * (a CR LF pair one space), and `&#n;` / `&#xh;` are expanded afterwards.
 */
inline std::string normalize_attr(const std::string& v) {
    std::string ws;
    ws.reserve(v.size());
    for (std::size_t i = 0; i < v.size(); ++i) {
        const char c = v[i];
        if (c == '\r') {
            ws += ' ';
            if (i + 1 < v.size() && v[i + 1] == '\n') ++i;
        } else if (c == '\n' || c == '\t') {
            ws += ' ';
        } else {
            ws += c;
        }
    }
    std::string out;
    out.reserve(ws.size());
    for (std::size_t i = 0; i < ws.size(); ++i) {
        if (ws[i] == '&' && i + 2 < ws.size() && ws[i + 1] == '#') {
            const std::size_t semi = ws.find(';', i);
            if (semi != std::string::npos) {
                const bool hex = ws[i + 2] == 'x';
                const std::string digits = ws.substr(i + (hex ? 3 : 2), semi - i - (hex ? 3 : 2));
                bool ok = !digits.empty();
                for (char d : digits)
                    ok = ok && (hex ? std::isxdigit(static_cast<unsigned char>(d)) != 0 : srvn_detail::is_digit(d));
                if (ok) {
                    utf8(out, std::strtoul(digits.c_str(), NULL, hex ? 16 : 10));
                    i = semi;
                    continue;
                }
            }
        }
        out += ws[i];
    }
    return out;
}
 
inline void normalize_tree(Element* el) {
    for (auto& kv : el->attrs) kv.second = normalize_attr(kv.second);
    for (auto& c : el->children) normalize_tree(c.get());
}
 
/** Output requests: read and dropped, as the reader drops H, R and observations. */
inline bool is_output_tag(const std::string& tag) {
    return starts_with(tag, "result-") || tag == "service-time-distribution" || tag == "mva-info" ||
           tag == "convergence-collection";
}
 
/** Model children of `el`: results and output requests are skipped. */
inline std::vector<const Element*> kids(const Element* el) {
    std::vector<const Element*> out;
    for (const auto& c : el->children)
        if (!is_output_tag(c->name)) out.push_back(c.get());
    return out;
}
 
/** `el.find(tag)`: the first direct child with that tag, or null. */
inline const Element* find(const Element* el, const std::string& tag) {
    for (const auto& c : el->children)
        if (c->name == tag) return c.get();
    return NULL;
}
 
inline std::vector<const Element*> findall(const Element* el, const std::string& tag) {
    return el->child_tags(tag);
}
 
inline bool in(const std::string& s, std::initializer_list<const char*> set) {
    for (const char* x : set)
        if (s == x) return true;
    return false;
}
 
inline void check(const Element* el, std::initializer_list<const char*> allowed,
                  std::initializer_list<const char*> kidtags = {}) {
    const std::string* nm = get(el, "name");
    const std::string where = (nm && !nm->empty()) ? " name=\"" + *nm + "\"" : std::string();
    for (const auto& kv : el->attrs)
        if (!in(kv.first, allowed))
            throw unsup("attribute \"" + kv.first + "\" of <" + el->name + where + "> has no SRVN spelling");
    for (const Element* k : kids(el))
        if (!in(k->name, kidtags))
            throw unsup("<" + k->name + "> inside <" + el->name + where + "> has no SRVN spelling");
}
 
/** Python's `float(text)`: surrounding whitespace, underscores between digits, inf/nan. */
inline bool py_float(const std::string& text, double& x) {
    std::size_t a = 0, b = text.size();
    while (a < b && srvn_detail::is_space(text[a])) ++a;
    while (b > a && srvn_detail::is_space(text[b - 1])) --b;
    std::string s = text.substr(a, b - a);
    std::size_t i = 0;
    std::string sign;
    if (i < s.size() && (s[i] == '+' || s[i] == '-')) sign = s[i++];
    const std::string rest = lower(s.substr(i));
    if (rest == "inf" || rest == "infinity") {
        x = sign == "-" ? -HUGE_VAL : HUGE_VAL;
        return true;
    }
    if (rest == "nan") {
        x = std::nan("");
        return true;
    }
    // digitpart := digit (["_"] digit)*
    std::string clean = sign;
    auto digitpart = [&](std::size_t& k) -> bool {
        if (k >= s.size() || !srvn_detail::is_digit(s[k])) return false;
        clean += s[k++];
        while (k < s.size()) {
            if (srvn_detail::is_digit(s[k])) clean += s[k++];
            else if (s[k] == '_' && k + 1 < s.size() && srvn_detail::is_digit(s[k + 1])) ++k;
            else break;
        }
        return true;
    };
    bool mant = digitpart(i);
    if (i < s.size() && s[i] == '.') {
        clean += '.';
        ++i;
        const bool frac = digitpart(i);
        mant = mant || frac;
    }
    if (!mant) return false;
    if (i < s.size() && (s[i] == 'e' || s[i] == 'E')) {
        clean += 'e';
        ++i;
        if (i < s.size() && (s[i] == '+' || s[i] == '-')) clean += s[i++];
        if (!digitpart(i)) return false;
    }
    if (i != s.size()) return false;
    x = std::strtod(clean.c_str(), NULL);
    return true;
}
 
/** `_num`: the attribute as `format_number(float(text))`, or `dflt` (null = None) when absent. */
inline const std::string* num(const Element* el, const std::string& key, std::string& buf,
                              const char* dflt = NULL) {
    const std::string* text = get(el, key);
    if (!text) {
        if (!dflt) return NULL;
        buf = dflt;
        return &buf;
    }
    double x = 0;
    if (!py_float(*text, x))
        throw unsup(key + "=\"" + *text + "\" of <" + el->name +
                    "> is not a number (SPEX and LQX expressions have no SRVN spelling here)");
    if (!std::isfinite(x)) throw unsup(key + "=\"" + *text + "\" of <" + el->name + "> is not finite");
    buf = format_number(x);
    return &buf;
}
 
/** `_num` with a default, which never returns None. */
inline std::string numd(const Element* el, const std::string& key, const char* dflt) {
    std::string buf;
    return *num(el, key, buf, dflt);
}
 
/** `[A-Za-z_][A-Za-z0-9_]+$` under re.match, where `$` also matches before a final newline. */
inline bool srvn_name_ok(const std::string& nm) {
    std::size_t n = nm.size();
    if (n > 0 && nm[n - 1] == '\n') --n;
    if (n < 2) return false;
    auto alpha = [](char c) { return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || c == '_'; };
    if (!alpha(nm[0])) return false;
    for (std::size_t i = 1; i < n; ++i)
        if (!alpha(nm[i]) && !srvn_detail::is_digit(nm[i])) return false;
    return true;
}
 
inline std::string name(const Element* el, const std::string& key = "name") {
    const std::string* nm = get(el, key);
    if (!nm) throw xerr("<" + el->name + "> has no " + key);
    if (!srvn_name_ok(*nm))
        throw unsup("the name \"" + *nm +
                    "\" is not an LQNS identifier (a letter or \"_\", then at least one letter, digit or \"_\"); "
                    "write the model with use_abstract_names=True");
    return *nm;
}
 
inline std::string join(const std::vector<std::string>& v, const std::string& sep) {
    std::string s;
    for (std::size_t i = 0; i < v.size(); ++i) s += (i ? sep : std::string()) + v[i];
    return s;
}
 
struct CallRow {
    std::string kind, dst;
    std::vector<std::string> vals;
};
 
/** `acts` maps phase -> <activity>; the E-section lines of one entry's phases. */
inline void phase_lists(const std::map<int, const Element*>& acts,
                        std::vector<std::pair<std::string, std::vector<std::string>>>& lines,
                        std::vector<CallRow>& calls) {
    const int K = acts.rbegin()->first;
    static const char* fields[4][3] = {{"s", "host-demand-mean", "0"},
                                       {"c", "host-demand-cvsq", "1"},
                                       {"Z", "think-time", "0"},
                                       {"M", "max-service-time", "0"}};
    for (int fi = 0; fi < 4; ++fi) {
        const std::string key = fields[fi][0];
        std::vector<std::string> vals;
        bool any = false;
        for (int k = 1; k <= K; ++k) {
            std::map<int, const Element*>::const_iterator it = acts.find(k);
            std::string buf;
            const std::string* v = it == acts.end() ? NULL : num(it->second, fields[fi][1], buf);
            any = any || v;
            vals.push_back(v ? *v : std::string(fields[fi][2]));
        }
        if (key == "s" || any) lines.emplace_back(key, vals);
        if (key == "c") {
            std::vector<std::string> det;
            bool anydet = false;
            for (int k = 1; k <= K; ++k) {
                std::map<int, const Element*>::const_iterator it = acts.find(k);
                const bool d =
                    it != acts.end() && upper(get(it->second, "call-order", "STOCHASTIC")) == "DETERMINISTIC";
                anydet = anydet || d;
                det.push_back(d ? "1" : "0");
            }
            if (anydet) lines.emplace_back("f", det);
        }
    }
    for (int k = 1; k <= K; ++k) {
        std::map<int, const Element*>::const_iterator it = acts.find(k);
        if (it == acts.end()) continue;
        std::set<std::pair<std::string, std::string>> seen;
        for (const Element* c : kids(it->second)) {
            if (c->name != "synch-call" && c->name != "asynch-call") continue;
            const std::pair<std::string, std::string> key(c->name == "synch-call" ? "y" : "z", name(c, "dest"));
            if (seen.count(key))
                throw unsup("phase " + std::to_string(k) + " of entry \"" + show(it->second, "name") + "\" calls \"" +
                            key.second + "\" twice; SRVN carries one count per phase");
            seen.insert(key);
            CallRow* row = NULL;
            for (CallRow& r : calls)
                if (r.kind == key.first && r.dst == key.second) row = &r;
            if (!row) {
                calls.push_back(CallRow{key.first, key.second, std::vector<std::string>(K, "0")});
                row = &calls.back();
            }
            row->vals[k - 1] = numd(c, "calls-mean", "0");
        }
    }
}
 
inline const char* proc_letter(const std::string& s) {
    static const std::map<std::string, const char*> t = {{"fcfs", "f"}, {"hol", "h"}, {"pri", "p"}, {"pp", "p"},
                                                         {"rand", "r"}, {"siro", "r"}, {"inf", "i"}, {"cfs", "c"},
                                                         {"gps", "c"},  {"ps", "s"}};
    std::map<std::string, const char*>::const_iterator it = t.find(s);
    return it == t.end() ? NULL : it->second;
}
 
inline const char* task_letter(const std::string& s) {
    static const std::map<std::string, const char*> t = {
        {"ref", "r"},  {"fcfs", "n"},  {"hol", "h"},     {"pri", "p"},       {"pp", "p"},     {"inf", "i"},
        {"poll", "P"}, {"burst", "b"}, {"uniform", "u"}, {"semaphore", "S"}, {"rwlock", "W"}};
    std::map<std::string, const char*>::const_iterator it = t.find(s);
    return it == t.end() ? NULL : it->second;
}
 
inline const char* rwlock_letter(const std::string& s) {
    if (s == "r-lock") return "R";
    if (s == "r-unlock") return "U";
    if (s == "w-lock") return "W";
    if (s == "w-unlock") return "X";
    return NULL;
}
 
inline const char* sem_letter(const std::string& s) {
    if (s == "signal") return "P";
    if (s == "wait") return "V";
    return NULL;
}
 
#define LINE_SRVN_ACT_ATTRS "name", "phase", "host-demand-mean", "host-demand-cvsq", "call-order", "think-time", \
                            "max-service-time"
 
struct TaskRef {
    const Element* t;
    const Element* p;
    const Element* g;
};
 
/** One task's `A` section, appended to `out`. */
inline void activity_section(const Element* t, const Element* ta, std::vector<std::string>& out) {
    check(ta, {}, {"activity", "precedence", "reply-entry"});
    out.push_back("");
    out.push_back("A " + show(t, "name"));
    for (const Element* a : findall(ta, "activity")) {
        check(a, {LINE_SRVN_ACT_ATTRS, "bound-to-entry"}, {"synch-call", "asynch-call"});
        const std::string an = name(a);
        out.push_back("  s " + an + " " + numd(a, "host-demand-mean", "0"));
        if (get(a, "host-demand-cvsq")) {
            std::string buf;
            out.push_back("  c " + an + " " + *num(a, "host-demand-cvsq", buf));
        }
        if (upper(get(a, "call-order", "STOCHASTIC")) == "DETERMINISTIC") out.push_back("  f " + an + " 1");
        static const char* zm[2][2] = {{"Z", "think-time"}, {"M", "max-service-time"}};
        for (int q = 0; q < 2; ++q) {
            std::string buf;
            const std::string* v = num(a, zm[q][1], buf);
            if (v && *v != "0") out.push_back("  " + std::string(zm[q][0]) + " " + an + " " + *v);
        }
        for (const Element* c : kids(a)) {
            check(c, {"dest", "calls-mean"});
            const std::string letter = c->name == "synch-call" ? "y" : "z";
            const std::string dst = name(c, "dest");
            out.push_back("  " + letter + " " + an + " " + dst + " " + numd(c, "calls-mean", "0"));
        }
    }
    // (activity, [entries]) in first-appearance order
    std::vector<std::pair<std::string, std::vector<std::string>>> replies;
    for (const Element* re : findall(ta, "reply-entry")) {
        check(re, {"name"}, {"reply-activity"});
        for (const Element* ra : findall(re, "reply-activity")) {
            check(ra, {"name"});
            const std::string an = show(ra, "name");
            std::pair<std::string, std::vector<std::string>>* row = NULL;
            for (auto& r : replies)
                if (r.first == an) row = &r;
            if (!row) {
                replies.emplace_back(an, std::vector<std::string>());
                row = &replies.back();
            }
            const std::string en = show(re, "name");
            bool have = false;
            for (const std::string& x : row->second) have = have || x == en;
            if (!have) row->second.push_back(en);
        }
    }
    std::map<std::string, std::vector<std::string>> pending(replies.begin(), replies.end());
    // lqns takes a reply list on the pre side of a connection only, so a terminal activity replies standalone
    auto ref = [&](const std::string& nm) -> std::string {
        std::map<std::string, std::vector<std::string>>::iterator it = pending.find(nm);
        if (it == pending.end()) return nm;
        const std::string s = nm + "[" + join(it->second, ", ") + "]";
        pending.erase(it);
        return s;
    };
    const std::string tn = show(t, "name");
    std::vector<std::string> conns;
    for (const Element* pr : findall(ta, "precedence")) {
        const std::vector<const Element*> parts = kids(pr);
        std::vector<const Element*> pre, post;
        for (const Element* k : parts) {
            if (in(k->name, {"pre", "pre-AND", "pre-OR"})) pre.push_back(k);
            if (starts_with(k->name, "post")) post.push_back(k);
        }
        if (pre.size() != 1 || post.size() > 1 || pre.size() + post.size() != parts.size())
            throw unsup("a <precedence> of task \"" + tn + "\" is not one pre list and at most one post list");
        const Element* p0 = pre[0];
        if (p0->name == "pre-AND") check(p0, {"quorum"}, {"activity"});
        else check(p0, {}, {"activity"});
        std::vector<std::string> names;
        for (const Element* x : findall(p0, "activity")) names.push_back(name(x));
        for (const Element* x : findall(p0, "activity")) check(x, {"name"});
        if (names.empty() || (p0->name == "pre" && names.size() != 1))
            throw xerr("a <" + p0->name + "> of task \"" + tn + "\" lists " + std::to_string(names.size()) +
                       " activities");
        bool anypending = false;
        for (const std::string& x : names) anypending = anypending || pending.count(x);
        if (post.empty() && !anypending) continue;  // a bare activity says nothing, and lqns refuses it
        std::vector<std::string> refs;
        for (const std::string& x : names) refs.push_back(ref(x));
        std::string s = join(refs, p0->name == "pre-AND" ? " & " : " + ");
        if (get(p0, "quorum")) {
            std::string buf;
            s += " (" + *num(p0, "quorum", buf) + ")";
        }
        if (!post.empty()) {
            const Element* q = post[0];
            const std::vector<const Element*> items = findall(q, "activity");
            std::string rhs;
            if (q->name == "post-OR") {
                check(q, {}, {"activity"});
                for (const Element* x : items) check(x, {"name", "prob"});
                std::vector<std::string> bs;
                for (const Element* x : items) {
                    const std::string pv = numd(x, "prob", "0");
                    bs.push_back("(" + pv + ") " + name(x));
                }
                rhs = join(bs, " + ");
            } else if (q->name == "post-LOOP") {
                check(q, {"end"}, {"activity"});
                if (items.size() != 1)
                    throw unsup("the loop in task \"" + tn + "\" has " + std::to_string(items.size()) +
                                " bodies; SRVN gives a loop one body");
                check(items[0], {"name", "count"});
                const std::string cnt = numd(items[0], "count", "1");
                rhs = cnt + " * " + name(items[0]);
                if (get(q, "end")) rhs += ", " + name(q, "end");
            } else if (q->name == "post" || q->name == "post-AND") {
                check(q, {}, {"activity"});
                for (const Element* x : items) check(x, {"name"});
                if (q->name == "post" && items.size() != 1)
                    throw xerr("a <post> of task \"" + tn + "\" lists " + std::to_string(items.size()) +
                               " activities");
                std::vector<std::string> ns;
                for (const Element* x : items) ns.push_back(name(x));
                rhs = join(ns, " & ");
            } else {
                throw unsup("<" + q->name + "> in task \"" + tn + "\" has no SRVN spelling");
            }
            if (items.empty()) throw xerr("a <" + q->name + "> of task \"" + tn + "\" lists no activities");
            s += " -> " + rhs;
        }
        conns.push_back(s);
    }
    for (const auto& r : replies)
        if (pending.count(r.first)) conns.push_back(ref(r.first));
    if (!conns.empty()) {
        out.push_back("  :");
        for (std::size_t i = 0; i < conns.size(); ++i)
            out.push_back("  " + conns[i] + (i + 1 < conns.size() ? ";" : ""));
    }
    out.push_back("-1");
}
 
}  // namespace srvn_out
 
/**
 * Translate an LQN XML document into SRVN text.
 *
 * @param xml_text  the LQN XML document
 * @param name      the model name for the header comment; empty means `<lqn-model name>`
 *                  (or "model" when the root has none)
 * @return          the SRVN document, newline-terminated
 * @throws InputError (`LINE:input:Format`) when the XML is malformed
 * @throws UnsupportedError (`LINE:unsupported:Format`) for content SRVN cannot express
 */
inline std::string lqnx2srvn(const std::string& xml_text, const std::string& name = std::string()) {
    using namespace srvn_out;
    std::unique_ptr<Element> doc;
    try {
        doc = xml::parse(xml_text);
    } catch (const InputError& e) {
        throw xerr(std::string("the LQN XML is malformed: ") + e.what());
    }
    normalize_tree(doc.get());
    const Element* root = doc.get();
    if (root->name != "lqn-model") throw xerr("the root element is <" + root->name + ">, not <lqn-model>");
    const std::string model_name = name.empty() ? get(root, "name", "model") : name;
    for (const Element* k : kids(root))
        if (k->name != "solver-params" && k->name != "processor") throw unsup("<" + k->name + "> has no SRVN spelling");
    std::vector<std::string> out;
    out.push_back("# SRVN model " + model_name + ", written by LINE");
    const Element* sp = find(root, "solver-params");
    std::string comment;
    std::vector<std::string> solver = {"1e-05", "50"};
    if (sp) {
        check(sp, {"comment", "conv_val", "it_limit", "print_int", "underrelax_coeff"}, {"pragma"});
        for (const Element* pr : findall(sp, "pragma")) {
            check(pr, {"param", "value"});
            out.push_back("#pragma " + get(pr, "param", "") + "=" + get(pr, "value", ""));
        }
        comment = get(sp, "comment", "");
        solver = {numd(sp, "conv_val", "1e-05"), numd(sp, "it_limit", "50")};
        std::string pb, ub;
        const std::string* pi = num(sp, "print_int", pb);
        const std::string* ur = num(sp, "underrelax_coeff", ub);
        if (pi || ur) solver.push_back(pi ? *pi : std::string("0"));
        if (ur) solver.push_back(*ur);
    }
    if (comment.find('"') != std::string::npos)
        throw unsup("the solver-params comment contains a double quote, which an SRVN string cannot hold");
    {
        std::vector<std::string> words;
        std::size_t i = 0;
        while (i < comment.size()) {
            while (i < comment.size() && srvn_detail::is_space(comment[i])) ++i;
            std::size_t j = i;
            while (j < comment.size() && !srvn_detail::is_space(comment[j])) ++j;
            if (j > i) words.push_back(comment.substr(i, j - i));
            i = j;
        }
        out.push_back("G \"" + join(words, " ") + "\" " + join(solver, " ") + " -1");
    }
 
    std::vector<const Element*> procs;
    std::vector<std::pair<const Element*, const Element*>> groups;
    std::vector<TaskRef> tasks;
    for (const Element* p : findall(root, "processor")) {
        check(p, {"name", "scheduling", "quantum", "multiplicity", "replication", "speed-factor"}, {"task", "group"});
        procs.push_back(p);
        for (const Element* k : kids(p)) {
            if (k->name == "group") {
                check(k, {"name", "share", "cap"}, {"task"});
                groups.emplace_back(k, p);
                for (const Element* t : findall(k, "task")) tasks.push_back(TaskRef{t, p, k});
            } else {
                tasks.push_back(TaskRef{k, p, NULL});
            }
        }
    }
 
    out.push_back("");
    out.push_back("P " + std::to_string(procs.size()));
    for (const Element* p : procs) {
        const std::string sched = lower(get(p, "scheduling", "fcfs"));
        const char* letter = proc_letter(sched);
        if (!letter)
            throw unsup("processor \"" + show(p, "name") + "\" uses scheduling \"" + sched +
                        "\", which SRVN cannot express");
        std::string s = "  p " + srvn_out::name(p) + " " + letter;
        if (std::string(letter) == "c" || std::string(letter) == "s") {
            s += " " + numd(p, "quantum", "0");
        } else if (get(p, "quantum")) {
            std::string buf;
            if (std::strtod(num(p, "quantum", buf)->c_str(), NULL) != 0)
                throw unsup("processor \"" + show(p, "name") + "\" has a quantum, which SRVN gives to \"ps\" and \"cfs\" only");
        }
        std::string b1, b2, b3;
        const std::string* mult = num(p, "multiplicity", b1);
        if (sched != "inf" && mult && *mult != "1") s += " m " + *mult;
        const std::string* repl = num(p, "replication", b2);
        if (repl && *repl != "1") s += " r " + *repl;
        const std::string* speed = num(p, "speed-factor", b3);
        if (speed && *speed != "1") s += " R " + *speed;
        out.push_back(s);
    }
    out.push_back("-1");
 
    if (!groups.empty()) {
        out.push_back("");
        out.push_back("U " + std::to_string(groups.size()));
        for (const auto& gp : groups) {
            const std::string cap = lower(get(gp.first, "cap", "false"));
            const std::string gn = srvn_out::name(gp.first);
            const std::string share = numd(gp.first, "share", "0");
            out.push_back("  g " + gn + " " + share + (cap == "true" ? " c" : "") + " " + show(gp.second, "name"));
        }
        out.push_back("-1");
    }
 
    std::vector<std::pair<const Element*, const Element*>> entries;
    std::vector<std::string> fans;
    out.push_back("");
    out.push_back("T " + std::to_string(tasks.size()));
    for (const TaskRef& tr : tasks) {
        const Element* t = tr.t;
        check(t, {"name", "scheduling", "multiplicity", "replication", "think-time", "priority", "queue-length"},
              {"entry", "task-activities", "fan-in", "fan-out"});
        const std::string sched = lower(get(t, "scheduling", "fcfs"));
        const char* letter = task_letter(sched);
        if (!letter)
            throw unsup("task \"" + show(t, "name") + "\" uses scheduling \"" + sched + "\", which SRVN cannot express");
        const std::vector<const Element*> ents = findall(t, "entry");
        if (ents.empty()) throw xerr("task \"" + show(t, "name") + "\" has no entries");
        const std::string tn = srvn_out::name(t);
        std::vector<std::string> ens;
        for (const Element* e : ents) ens.push_back(srvn_out::name(e));
        std::string s = "  t " + tn + " " + letter + " " + join(ens, " ") + " -1 " + show(tr.p, "name");
        std::string b1, b2, b3, b4, b5;
        const std::string* prio = num(t, "priority", b1);
        if (prio) s += " " + *prio;
        const std::string* think = num(t, "think-time", b2);
        if (think && *think != "0") s += " z " + *think;
        const std::string* mult = num(t, "multiplicity", b3);
        if (sched != "inf" && mult && *mult != "1") s += " m " + *mult;
        const std::string* repl = num(t, "replication", b4);
        if (repl && *repl != "1") s += " r " + *repl;
        if (tr.g) s += " g " + show(tr.g, "name");
        const std::string* qlen = num(t, "queue-length", b5);
        if (qlen) s += " q " + *qlen;
        out.push_back(s);
        for (const Element* f : findall(t, "fan-in")) {
            check(f, {"source", "value"});
            const std::string src = srvn_out::name(f, "source");
            fans.push_back("  I " + src + " " + show(t, "name") + " " + numd(f, "value", "1"));
        }
        for (const Element* f : findall(t, "fan-out")) {
            check(f, {"dest", "value"});
            const std::string dst = srvn_out::name(f, "dest");
            fans.push_back("  O " + show(t, "name") + " " + dst + " " + numd(f, "value", "1"));
        }
        for (const Element* e : ents) entries.emplace_back(e, t);
    }
    out.insert(out.end(), fans.begin(), fans.end());
    out.push_back("-1");
 
    std::map<std::string, std::string> bound;
    for (const TaskRef& tr : tasks) {
        const Element* ta = find(tr.t, "task-activities");
        if (!ta) continue;
        for (const Element* a : findall(ta, "activity")) {
            const std::string* be = get(a, "bound-to-entry");
            if (be && !bound.count(*be)) bound[*be] = show(a, "name");
        }
    }
    out.push_back("");
    out.push_back("E " + std::to_string(entries.size()));
    for (const auto& et : entries) {
        const Element* e = et.first;
        check(e, {"name", "type", "open-arrival-rate", "priority", "semaphore", "rwlock"},
              {"forwarding", "entry-phase-activities"});
        const std::string en = show(e, "name");
        std::string b1, b2;
        const std::string* rate = num(e, "open-arrival-rate", b1);
        if (rate && *rate != "0") out.push_back("  a " + en + " " + *rate);
        const std::string* prio = num(e, "priority", b2);
        if (prio) out.push_back("  p " + en + " " + *prio);
        if (const std::string* sem = get(e, "semaphore")) {
            if (!sem_letter(*sem)) throw unsup("entry \"" + en + "\" has semaphore=\"" + *sem + "\"");
            out.push_back(std::string("  ") + sem_letter(*sem) + " " + en);
        }
        if (const std::string* rw = get(e, "rwlock")) {
            if (!rwlock_letter(*rw)) throw unsup("entry \"" + en + "\" has rwlock=\"" + *rw + "\"");
            out.push_back(std::string("  ") + rwlock_letter(*rw) + " " + en);
        }
        const Element* epa = find(e, "entry-phase-activities");
        std::map<int, const Element*> acts;
        if (epa) {
            check(epa, {}, {"activity"});
            for (const Element* a : findall(epa, "activity")) {
                check(a, {LINE_SRVN_ACT_ATTRS}, {"synch-call", "asynch-call"});
                const int k = static_cast<int>(std::strtod(numd(a, "phase", "1").c_str(), NULL));
                if (k < 1 || acts.count(k))
                    throw xerr("entry \"" + en + "\" has two activities for phase " + std::to_string(k));
                acts[k] = a;
            }
        }
        std::map<std::string, std::string>::const_iterator b = bound.find(en);
        if (b != bound.end()) {
            if (!acts.empty())
                throw unsup("entry \"" + en + "\" has both phases and a start activity, which SRVN cannot express");
            out.push_back("  A " + en + " " + b->second);
        }
        if (!acts.empty()) {
            std::vector<std::pair<std::string, std::vector<std::string>>> lines;
            std::vector<CallRow> calls;
            phase_lists(acts, lines, calls);
            for (const auto& l : lines) out.push_back("  " + l.first + " " + en + " " + join(l.second, " ") + " -1");
            for (const CallRow& c : calls)
                out.push_back("  " + c.kind + " " + en + " " + c.dst + " " + join(c.vals, " ") + " -1");
        }
        for (const Element* f : findall(e, "forwarding")) {
            check(f, {"dest", "prob"});
            const std::string dst = srvn_out::name(f, "dest");
            out.push_back("  F " + en + " " + dst + " " + numd(f, "prob", "0") + " -1");
        }
    }
    out.push_back("-1");
 
    for (const TaskRef& tr : tasks) {
        const Element* ta = find(tr.t, "task-activities");
        if (ta) activity_section(tr.t, ta, out);
    }
    std::string text;
    for (const std::string& l : out) {
        text += l;
        text += '\n';
    }
    return text;
}
 
#undef LINE_SRVN_ACT_ATTRS
 
/**
 * Write a layered model as SRVN text: `write_lqnx`, then `lqnx2srvn`, with LF line endings.
 *
 * @param m                   the intermediate model
 * @param path                file to create
 * @param use_abstract_names  rename elements P1/T1/E1/A1 first, which also makes every name an LQNS identifier
 * @throws UnsupportedError (`LINE:unsupported:Format`) for content SRVN cannot express
 */
template <class T>
void write_srvn(const LqnModel<T>& m, const std::string& path, bool use_abstract_names = false) {
    const std::string xml_text = lqnx_to_string(m, m.name.empty() ? std::string("LQN") : m.name, use_abstract_names);
    const std::string text = lqnx2srvn(xml_text, m.name);
    std::ofstream f(path.c_str(), std::ios::binary);
    if (!f) throw InputError(ErrorKind{"File"}, "cannot write " + path);
    f << text;
}
 
}  // namespace lqn
}  // namespace line
 
#endif  // LINE_LANG_LQN_SRVN_WRITER_H