// =========================================================================== // sst_parser.cpp -- Spec-conformant .sst parser (NS-SST-0001 Part XIV). // =========================================================================== #include "sst_parser.h" #include #include namespace nordshrift { namespace { // Recognized pipeline phase tokens, in mandatory order (§7.3). const std::vector kPhaseOrder = { "lex", "parse", "desugar", "bind", "infer", "effect-check", "rule-eval", "ir", "java-emit", "java-print", "diagnostic" }; // Phases that may not be skipped (PIPE-02). bool mandatoryPhase(const std::string& p) { return p == "lex" || p == "parse" || p == "bind" || p == "infer" || p == "java-print"; } int phaseRank(const std::string& p) { for (size_t i = 0; i < kPhaseOrder.size(); i++) if (kPhaseOrder[i] == p) return (int)i; return -1; } struct Parser { const std::vector& t; const std::string& file; DiagnosticBag& diags; size_t i = 0; Sheet sheet; Parser(const std::vector& toks, const std::string& f, DiagnosticBag& d) : t(toks), file(f), diags(d) { sheet.file = f; } // ---- token cursor helpers ------------------------------------------ const Token& cur() const { return t[i]; } const Token& peek(int off = 1) const { size_t p = i + (size_t)off; return p < t.size() ? t[p] : t.back(); } bool is(Tok k) const { return cur().kind == k; } bool isIdent(const char* s) const { return cur().kind == Tok::Ident && cur().text == s; } const Token& take() { return t[i < t.size() - 1 ? i++ : i]; } void skipNewlines() { while (is(Tok::Newline)) i++; } void errAt(int line, const std::string& code, const std::string& msg, const std::string& ref, bool recover = false) { diags.error(code, file, line, msg, ref, recover); } // Consume tokens until the next Newline (error recovery). void syncToNewline() { while (!is(Tok::Newline) && !is(Tok::Eof)) i++; if (is(Tok::Newline)) i++; } // Enter a block body: expects Colon Newline Indent. Returns true on success. bool enterBlock() { if (!is(Tok::Colon)) return false; i++; // ':' if (is(Tok::Newline)) i++; if (!is(Tok::Indent)) return false; i++; // INDENT return true; } bool atBlockEnd() const { return is(Tok::Dedent) || is(Tok::Eof); } void exitBlock() { if (is(Tok::Dedent)) i++; } // ---- scalar / list readers ----------------------------------------- // Read a scalar while PRESERVING its lexical type (String support, 1.4). // A quoted "..." literal becomes ScalarKind::String; everything else keeps // its integer/version/boolean/identifier kind. This is the typed primitive; // readScalarText() below is the text-only wrapper the rest of the parser // has always used, so existing behaviour is unchanged. TypedScalar readTypedScalar() { const Token& tk = cur(); TypedScalar ts; ts.line = tk.line; switch (tk.kind) { case Tok::String: ts.kind = ScalarKind::String; ts.text = tk.text; i++; break; case Tok::Integer: ts.kind = ScalarKind::Integer; ts.text = tk.text; i++; break; case Tok::Version: ts.kind = ScalarKind::Version; ts.text = tk.text; i++; break; case Tok::Ident: { // booleans are identifiers at the lexical level if (tk.text == "true" || tk.text == "false" || tk.text == "on" || tk.text == "off") { ts.kind = ScalarKind::Boolean; } else { ts.kind = ScalarKind::Identifier; } ts.text = tk.text; i++; break; } default: ts.kind = ScalarKind::None; break; } return ts; } std::string readScalarText() { // scalar-value ::= string | boolean | integer | version | identifier return readTypedScalar().text; } // list-literal ::= "[" [ scalar { "," scalar } ] "]" // (line-continuation form is already stitched by the lexer into one line) std::vector readList() { std::vector items; if (is(Tok::LBracket)) { i++; while (!is(Tok::RBracket) && !is(Tok::Newline) && !is(Tok::Eof)) { if (is(Tok::Comma)) { i++; continue; } std::string s = readScalarText(); if (s.empty() && !is(Tok::Comma) && !is(Tok::RBracket)) { i++; continue; } items.push_back(s); } if (is(Tok::RBracket)) i++; } return items; } bool parseBool(const std::string& s, bool dflt) { if (s == "true" || s == "on") return true; if (s == "false" || s == "off") return false; return dflt; } // ---- top level ------------------------------------------------------ Sheet run() { parsePragmas(); skipNewlines(); parseSheetBlock(); skipNewlines(); parseImports(); skipNewlines(); // sections in any order while (!is(Tok::Eof)) { if (is(Tok::Newline)) { i++; continue; } if (is(Tok::Dedent)) { i++; continue; } if (!parseSection()) { // unknown top-level construct: report and recover errAt(cur().line, "NSS-E-0100", "unexpected token '" + cur().text + "' at top level", "§2.1", true); syncToNewline(); } skipNewlines(); } // pragma presence check (NSS-E-0003 / 0004) if (!sheet.pragmas.hasNordshrift) { errAt(1, "NSS-E-0003", "missing required #nordshrift pragma", "§1.6"); } else { const std::string& v = sheet.pragmas.nordshrift; if (v != "1.0" && v != "1.0.0") { errAt(sheet.pragmas.nordshriftLine, "NSS-E-0004", "unsupported #nordshrift version '" + v + "' (this tool supports 1.0)", "§1.6"); } } if (!sheet.meta.present) { errAt(1, "NSS-E-0010", "no sheet block found (exactly one is required)", "SST-01"); } return sheet; } // ---- pragmas -------------------------------------------------------- void parsePragmas() { while (is(Tok::Pragma)) { std::string name = cur().text; int line = cur().line; i++; std::string operand = readScalarText(); if (name == "nordshrift") { sheet.pragmas.nordshrift = operand; sheet.pragmas.hasNordshrift = true; sheet.pragmas.nordshriftLine = line; } else if (name == "sleela") { sheet.pragmas.sleela = operand; } else if (name == "encoding") { sheet.pragmas.encoding = operand; } if (is(Tok::Newline)) i++; } } // ---- sheet block ---------------------------------------------------- void parseSheetBlock() { if (!isIdent("sheet")) return; if (sheet.meta.present) { errAt(cur().line, "NSS-E-0010", "multiple sheet blocks in one file", "SST-01"); } sheet.meta.present = true; sheet.meta.line = cur().line; i++; // 'sheet' if (is(Tok::Ident)) sheet.meta.name = take().text; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string key = cur().text; i++; if (key == "version") sheet.meta.version = readScalarText(); else if (key == "author") sheet.meta.author = readScalarText(); else if (key == "description") sheet.meta.description = readScalarText(); else if (key == "extends") sheet.meta.extends = readScalarText(); else if (key == "tags") sheet.meta.tags = readList(); else { /* unknown sheet directive: ignore */ } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- imports -------------------------------------------------------- void parseImports() { while (isIdent("import")) { Import im; im.line = cur().line; i++; // 'import' im.path = readScalarText(); if (isIdent("as")) { i++; if (is(Tok::Ident)) im.alias = take().text; } if (isIdent("only")) { i++; im.only = readList(); im.hasOnly = true; } else if (isIdent("except")) { i++; im.except = readList(); im.hasExcept = true; } // IMPORT-05 alias uniqueness for (auto& e : sheet.imports) if (!im.alias.empty() && e.alias == im.alias) errAt(im.line, "NSS-E-0021", "duplicate import alias '" + im.alias + "'", "IMPORT-05"); sheet.imports.push_back(im); if (is(Tok::Newline)) i++; skipNewlines(); } } // ---- section dispatch ---------------------------------------------- bool parseSection() { if (!is(Tok::Ident)) return false; const std::string& kw = cur().text; if (kw == "source") { parseSource(); return true; } if (kw == "target") { parseTarget(); return true; } if (kw == "pipeline") { parsePipeline(sheet.pipeline); return true; } if (kw == "rules") { parseRules(); return true; } if (kw == "effects") { parseEffects(); return true; } if (kw == "derive") { parseDerive(sheet.derive); return true; } if (kw == "guards") { parseGuards(sheet.guards); return true; } if (kw == "interop") { parseInterop(); return true; } if (kw == "network") { parseNetwork(); return true; } if (kw == "finance") { parseFinance(); return true; } if (kw == "strings") { parseStrings(); return true; } if (kw == "reach") { parseReach(); return true; } if (kw == "measure") { parseMeasure(); return true; } if (kw == "subject") { parseSubject(); return true; } if (kw == "object") { parseInputObject(); return true; } if (kw == "rule") { parseRuleBlock(); return true; } if (kw == "profile") { parseProfile(); return true; } return false; } // ---- generic SLeeLa input object ------------------------------- void parseInputObject() { InputObject obj; const int ln = cur().line; i++; // object std::string category = readScalarText(); if (!inputObjectCategoryFromName(category, obj.category)) { errAt(ln, "NSS-E-OBJ-001", "unknown input-object category '" + category + "'", "SST-OBJECT-CATEGORY", true); } if (is(Tok::Ident) || is(Tok::String)) obj.identity = take().text; if (!enterBlock()) { errAt(ln, "NSS-E-OBJ-002", "input object requires a block", "SST-OBJECT-BLOCK", true); if (!obj.identity.empty()) sheet.inputObjects.push_back(std::move(obj)); syncToNewline(); return; } obj.line = ln; while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int keyLine = cur().line; std::string key = cur().text; i++; if (is(Tok::Colon)) i++; if (key == "type") obj.type = readScalarText(); else if (key == "source") obj.source = readScalarText(); else if (key == "target") obj.target = readScalarText(); else if (key == "value") obj.value = readScalarText(); else if (key == "inputs") obj.inputs = readListOrScalar(); else if (key == "outputs") obj.outputs = readListOrScalar(); else if (key == "property") { std::string name = readScalarText(); std::string value = readScalarText(); if (name.empty()) errAt(keyLine, "NSS-E-OBJ-003", "object property requires a name", "SST-OBJECT-PROPERTY", true); else if (obj.properties.size() >= 64) errAt(keyLine, "NSS-E-OBJ-004", "input object property limit exceeded", "SST-OBJECT-BOUND", true); else obj.properties[name] = value; } else { // Unknown object members are rejected rather than silently // becoming a different API contract. errAt(keyLine, "NSS-E-OBJ-005", "unknown input object member '" + key + "'", "SST-OBJECT-MEMBER", true); (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); std::string error; if (!inputObjectValidate(obj, error)) errAt(ln, "NSS-E-OBJ-006", error, "SST-OBJECT-VALIDATE", true); else sheet.inputObjects.push_back(std::move(obj)); } // ---- strings (first-class String values, 1.4) ---------------------- // A `strings:` block declares named String values: // strings: // greeting "Hello, world" // banner "SLeeLa text surface" // The value MUST be a quoted String literal. A non-String scalar (integer, // version, bare identifier) in this block is a typed error (NSS-E-STR-001) // -- the block is closed to the String type, so a sheet cannot silently // mis-type a value. Names must be unique (NSS-E-STR-002). void parseStrings() { sheet.strings.present = true; sheet.strings.line = cur().line; i++; // 'strings' if (!enterBlock()) { errAt(sheet.strings.line, "NSS-E-STR-003", "strings block requires an indented body", "SST-STRINGS-BLOCK", true); syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int keyLine = cur().line; std::string name = cur().text; i++; if (is(Tok::Colon)) i++; TypedScalar ts = readTypedScalar(); if (!ts.present()) { errAt(keyLine, "NSS-E-STR-004", "string '" + name + "' has no value", "SST-STRINGS-VALUE", true); } else if (!ts.isString()) { errAt(ts.line, "NSS-E-STR-001", "string '" + name + "' requires a quoted String literal, got " + scalarKindName(ts.kind), "SST-STRINGS-TYPE", true); } else { bool dup = false; for (const auto& v : sheet.strings.vars) if (v.name == name) { dup = true; break; } if (dup) { errAt(keyLine, "NSS-E-STR-002", "duplicate string name '" + name + "'", "SST-STRINGS-UNIQUE", true); } else if (sheet.strings.vars.size() >= 256) { errAt(keyLine, "NSS-E-STR-005", "strings block limit (256) exceeded", "SST-STRINGS-BOUND", true); } else { StringVar sv; sv.name = name; sv.value = ts.text; sv.line = keyLine; sheet.strings.vars.push_back(std::move(sv)); } } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- source --------------------------------------------------------- void parseSource() { sheet.source.present = true; sheet.source.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (key == "root") { sheet.source.root = readScalarText(); sheet.source.hasRoot = true; sheet.source.rootLine = ln; } else if (key == "glob") { std::string g = readScalarText(); if (!g.empty() && g[0] == '/') errAt(ln, "NSS-E-0032", "absolute path in source.glob is not permitted: '" + g + "'", "SRC-03"); sheet.source.globs.push_back(g); } else if (key == "exclude") sheet.source.exclude = readList(); else if (key == "encoding") sheet.source.encoding = readScalarText(); else if (key == "watch") sheet.source.watch = parseBool(readScalarText(), false); if (is(Tok::Newline)) i++; } exitBlock(); } // ---- target --------------------------------------------------------- Layout parseLayout(const std::string& s) { if (s == "flat") return Layout::Flat; if (s == "package-mapped") return Layout::PackageMapped; if (s == "custom") return Layout::Custom; return Layout::MirrorSource; } void parseTarget() { sheet.target.present = true; sheet.target.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (key == "root") { sheet.target.root = readScalarText(); sheet.target.hasRoot = true; } else if (key == "layout") { sheet.target.layout = parseLayout(readScalarText()); sheet.target.hasLayout = true; } else if (key == "java-version") { std::string v = readScalarText(); sheet.target.javaVersion = v.empty() ? 0 : std::stoi(v); sheet.target.hasJavaVersion = true; sheet.target.javaVersionLine = ln; if (sheet.target.javaVersion < 17) errAt(ln, "NSS-E-0040", "target.java-version must be >= 17 (found " + v + ")", "TGT-01"); } else if (key == "package-root") sheet.target.packageRoot = readScalarText(); else if (key == "overwrite") sheet.target.overwrite = parseBool(readScalarText(), true); else if (key == "source-map") sheet.target.sourceMap = parseBool(readScalarText(), true); else if (key == "optimize") sheet.target.optimize = parseBool(readScalarText(), false); else if (key == "clean") sheet.target.clean = parseBool(readScalarText(), false); else if (key == "target-language") { // Nordshrift triplet superset std::string v = readScalarText(); if (v == "sleela") sheet.target.language = TargetLang::Sleela; else if (v == "c") sheet.target.language = TargetLang::C; else sheet.target.language = TargetLang::Java; } else if (key == "layout-map") { sheet.target.layoutMap = readPairBlock(); continue; } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- pipeline (also used inside profiles) --------------------------- Verbosity parseVerbosity(const std::string& s) { if (s == "silent") return Verbosity::Silent; if (s == "quiet") return Verbosity::Quiet; if (s == "verbose") return Verbosity::Verbose; if (s == "debug") return Verbosity::Debug; return Verbosity::Normal; } void parsePipeline(Pipeline& p) { p.present = true; p.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (key == "phases") { p.phases = readList(); p.phasesLine = ln; checkPhaseOrder(p.phases, ln); } else if (key == "skip") { p.skip = readList(); checkSkip(p.skip, ln); } else if (key == "parallel-threshold") { std::string v = readScalarText(); p.parallelThreshold = v.empty()?1:std::stoi(v); } else if (key == "cache") p.cache = parseBool(readScalarText(), true); else if (key == "cache-dir")p.cacheDir = readScalarText(); else if (key == "verbosity")p.verbosity = parseVerbosity(readScalarText()); else if (key == "fail-fast")p.failFast = parseBool(readScalarText(), false); if (is(Tok::Newline)) i++; } exitBlock(); } void checkPhaseOrder(const std::vector& phases, int ln) { int last = -1; for (auto& p : phases) { int r = phaseRank(p); if (r < 0) continue; if (r < last) { errAt(ln, "NSS-E-0050", "pipeline phases specified out of mandatory order at '" + p + "'", "PIPE-01"); return; } last = r; } } void checkSkip(const std::vector& skip, int ln) { for (auto& p : skip) if (mandatoryPhase(p)) errAt(ln, "NSS-E-0051", "cannot skip mandatory phase '" + p + "'", "PIPE-02"); } // ---- rules ---------------------------------------------------------- Severity parseSeverity(const std::string& s) { if (s == "warning") return Severity::Warning; if (s == "notice") return Severity::Notice; return Severity::Error; } void parseRules() { sheet.rules.present = true; sheet.rules.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string key = cur().text; i++; if (key == "activate") sheet.rules.activate = readList(); else if (key == "deactivate") sheet.rules.deactivate = readList(); else if (key == "severity") { // nested block if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string rn = take().text; Severity sv = parseSeverity(readScalarText()); sheet.rules.severity[rn] = sv; if (is(Tok::Newline)) i++; } exitBlock(); } continue; } else if (key == "config") { // nested config block if (enterBlock()) { // config: : key value ... (we accept flat key value) while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string k = take().text; std::string v = readScalarText(); (void)k; (void)v; // stored under rule blocks in a later pass if (is(Tok::Newline)) i++; } exitBlock(); } continue; } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- effects -------------------------------------------------------- EffectPolicy parsePolicy(const std::string& s) { if (s == "lenient") return EffectPolicy::Lenient; if (s == "audit") return EffectPolicy::Audit; if (s == "off") return EffectPolicy::Off; return EffectPolicy::Strict; } void parseEffects() { sheet.effects.present = true; sheet.effects.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string key = cur().text; i++; if (key == "policy") sheet.effects.policy = parsePolicy(readScalarText()); else if (key == "declare") sheet.effects.declare = readList(); else if (key == "default-effect")sheet.effects.defaultEffect = readScalarText(); else if (key == "aliases") { // nested block if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string an = take().text; sheet.effects.aliases[an] = readList(); if (is(Tok::Newline)) i++; } exitBlock(); } continue; } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- derive --------------------------------------------------------- DeriveStyle parseStyle(const std::string& s) { if (s == "immutable-class") return DeriveStyle::ImmutableClass; if (s == "builder") return DeriveStyle::Builder; if (s == "lombok") return DeriveStyle::Lombok; return DeriveStyle::Record; } void parseDerive(Derive& d) { d.present = true; d.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (key == "lens") d.lens = parseBool(readScalarText(), false); else if (key == "projection") d.projection = parseBool(readScalarText(), false); else if (key == "equality") d.equality = parseBool(readScalarText(), false); else if (key == "hashcode") d.hashcode = parseBool(readScalarText(), false); else if (key == "toString") d.toStringD = parseBool(readScalarText(), false); else if (key == "copy") d.copy = parseBool(readScalarText(), false); else if (key == "builder") { d.builder = parseBool(readScalarText(), false); d.hasBuilder = true; } else if (key == "target-style"){ d.targetStyle = parseStyle(readScalarText()); d.hasTargetStyle = true; } (void)ln; if (is(Tok::Newline)) i++; } // DRV-01: builder true with target-style record if (d.hasBuilder && d.builder && d.hasTargetStyle && d.targetStyle == DeriveStyle::Record) errAt(d.line, "NSS-E-0080", "derive builder true combined with target-style record", "DRV-01"); exitBlock(); } // ---- guards --------------------------------------------------------- GuardMode parseGuardMode(const std::string& s) { if (s == "compile-only") return GuardMode::CompileOnly; if (s == "runtime-only") return GuardMode::RuntimeOnly; if (s == "off") return GuardMode::Off; return GuardMode::CompileAndRuntime; } FailureAction parseFailure(const std::string& s) { if (s == "assert") return FailureAction::Assert; if (s == "log-and-continue") return FailureAction::LogAndContinue; if (s == "halt") return FailureAction::Halt; return FailureAction::Throw; } void parseGuards(Guards& g) { g.present = true; g.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string key = cur().text; i++; if (key == "mode") g.mode = parseGuardMode(readScalarText()); else if (key == "on-failure") g.onFailure = parseFailure(readScalarText()); else if (key == "message-format") g.messageFormat = readScalarText(); if (is(Tok::Newline)) i++; } exitBlock(); } // ---- interop -------------------------------------------------------- NullWrap parseNullWrap(const std::string& s) { if (s == "nullable-annotation") return NullWrap::NullableAnnotation; if (s == "trust") return NullWrap::Trust; return NullWrap::Maybe; } CheckedEx parseCheckedEx(const std::string& s) { if (s == "propagate") return CheckedEx::Propagate; if (s == "rethrow-unchecked") return CheckedEx::RethrowUnchecked; return CheckedEx::Wrap; } void parseInterop() { sheet.interop.present = true; sheet.interop.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (key == "assume-impure") sheet.interop.assumeImpure = parseBool(readScalarText(), false); else if (key == "null-wrapping") { sheet.interop.nullWrapping = parseNullWrap(readScalarText()); sheet.interop.hasNullWrapping = true; if (sheet.interop.nullWrapping == NullWrap::Trust) diags.warning("NSS-W-0100", file, ln, "null-wrapping trust mode activated", "§12.4"); } else if (key == "checked-exceptions") sheet.interop.checkedExceptions = parseCheckedEx(readScalarText()); else if (key == "package-allow") sheet.interop.packageAllow = readList(); else if (key == "package-deny") sheet.interop.packageDeny = readList(); else if (key == "type-mapping") { sheet.interop.typeMapping = readPairBlock(); continue; } if (is(Tok::Newline)) i++; } exitBlock(); } // A nested block of "key value" or "string string" pairs. std::map readPairBlock() { std::map m; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } std::string k = readScalarText(); std::string v = readScalarText(); if (!k.empty()) m[k] = v; if (is(Tok::Newline)) i++; } exitBlock(); } return m; } // Read either a list literal (`[a, b]`) or a single scalar as a 1-item // list. Used by the network/finance blocks which accept both plural // (`objects: [ ... ]`) and singular repeated (`object: X`) forms. std::vector readListOrScalar() { if (is(Tok::LBracket)) return readList(); std::vector one; std::string s = readScalarText(); if (!s.empty()) one.push_back(s); return one; } // ---- network block (NS-SST-NET-0001) ------------------------------- void parseNetwork() { sheet.network.present = true; sheet.network.line = cur().line; i++; // 'network' if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (is(Tok::Colon)) i++; // optional ':' after the key if (key == "objects" || key == "object") { for (const auto& name : readListOrScalar()) { NetworkObject o; if (!networkObjectFromName(name, o)) { errAt(ln, "NSS-E-NET-001", "unknown network object '" + name + "'", "SST-NET-OBJECT", true); } else if (std::find(sheet.network.objects.begin(), sheet.network.objects.end(), o) == sheet.network.objects.end()) { sheet.network.objects.push_back(o); } } } else if (key == "transports" || key == "transport") { for (const auto& name : readListOrScalar()) { NetworkTransport tr; if (!networkTransportFromName(name, tr)) { errAt(ln, "NSS-E-NET-002", "unknown network transport '" + name + "'", "SST-NET-TRANSPORT", true); } else if (std::find(sheet.network.transports.begin(), sheet.network.transports.end(), tr) == sheet.network.transports.end()) { sheet.network.transports.push_back(tr); } } } else if (key == "address-family") { std::string v = readScalarText(); if (!networkAddressFamilyFromName(v, sheet.network.addressFamily)) errAt(ln, "NSS-E-NET-003", "unknown network address-family '" + v + "'", "SST-NET-ADDRESS-FAMILY", true); } else if (key == "tls") { sheet.network.tls = parseBool(readScalarText(), false); } else { // unknown network directive: ignore the value (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- reach block (SST.MUNCTION.md, Munction 1.3) ------------------- void parseReach() { sheet.reach.present = true; sheet.reach.line = cur().line; i++; // 'reach' if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (is(Tok::Colon)) i++; if (key == "verbs" || key == "verb") { for (const auto& name : readListOrScalar()) { ReachVerb v; if (!reachVerbFromName(name, v)) { errAt(ln, "NSS-E-MUN-001", "unknown Munction verb '" + name + "'", "SST-MUN-VERB", true); } else if (std::find(sheet.reach.verbs.begin(), sheet.reach.verbs.end(), v) == sheet.reach.verbs.end()) { sheet.reach.verbs.push_back(v); } } } else if (key == "channels" || key == "channel") { for (const auto& name : readListOrScalar()) { ReachChannel c; if (!reachChannelFromName(name, c)) { errAt(ln, "NSS-E-MUN-002", "unknown Munction channel '" + name + "'", "SST-MUN-CHANNEL", true); } else if (std::find(sheet.reach.channels.begin(), sheet.reach.channels.end(), c) == sheet.reach.channels.end()) { sheet.reach.channels.push_back(c); } } } else if (key == "min-verbs") { sheet.reach.minVerbs = (int)std::strtol(readScalarText().c_str(), nullptr, 10); } else if (key == "max-verbs") { sheet.reach.maxVerbs = (int)std::strtol(readScalarText().c_str(), nullptr, 10); } else if (key == "receivable") { sheet.reach.receivable = parseBool(readScalarText(), true); } else if (key == "coherent") { sheet.reach.coherent = parseBool(readScalarText(), true); } else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } // The sanity bound (4..16) is fixed by the language; a sheet may narrow // but never widen it. Clamp and report if it tries to widen. if (sheet.reach.minVerbs < 4) { errAt(sheet.reach.line, "NSS-E-MUN-003", "reach min-verbs below the Munction floor of 4", "SST-MUN-BOUND", true); sheet.reach.minVerbs = 4; } if (sheet.reach.maxVerbs > 16) { errAt(sheet.reach.line, "NSS-E-MUN-004", "reach max-verbs above the Munction ceiling of 16", "SST-MUN-BOUND", true); sheet.reach.maxVerbs = 16; } exitBlock(); } // ---- measure block (SST.SYNCHRO.md, Synchro 1.3) ------------------- void parseMeasure() { sheet.measure.present = true; sheet.measure.line = cur().line; i++; // 'measure' if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (is(Tok::Colon)) i++; if (key == "metrics" || key == "metric") { for (const auto& name : readListOrScalar()) { MeasureMetric mm; if (!measureMetricFromName(name, mm)) { errAt(ln, "NSS-E-SYN-001", "unknown Synchro metric '" + name + "'", "SST-SYN-METRIC", true); } else if (std::find(sheet.measure.metrics.begin(), sheet.measure.metrics.end(), mm) == sheet.measure.metrics.end()) { sheet.measure.metrics.push_back(mm); } } } else if (key == "timeout-ms" || key == "timeout") { sheet.measure.timeoutMs = (int)std::strtol(readScalarText().c_str(), nullptr, 10); sheet.measure.hasTimeout = true; } else if (key == "honest") { bool h = parseBool(readScalarText(), true); // Synchro is honest by construction; a sheet cannot disable it. if (!h) errAt(ln, "NSS-E-SYN-002", "Synchro is honest by construction; 'honest false' is not permitted", "SST-SYN-HONEST", true); sheet.measure.honest = true; } else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- finance block (SST.FINANCIAL.md) ------------------------------ void parseFinance() { sheet.finance.present = true; sheet.finance.line = cur().line; i++; // 'finance' if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (is(Tok::Colon)) i++; // optional ':' after the key if (key == "objects" || key == "object" || key == "components" || key == "component") { for (const auto& name : readListOrScalar()) { FinanceObject o; if (!financeObjectFromName(name, o)) { errAt(ln, "NSS-E-FIN-001", "unknown finance object '" + name + "'", "SST-FIN-OBJECT", true); } else if (std::find(sheet.finance.objects.begin(), sheet.finance.objects.end(), o) == sheet.finance.objects.end()) { sheet.finance.objects.push_back(o); } } } else if (key == "currency") { sheet.finance.currency = readScalarText(); sheet.finance.hasCurrency = !sheet.finance.currency.empty(); } else if (key == "period" || key == "period-convention") { std::string v = readScalarText(); if (!financePeriodFromName(v, sheet.finance.period)) errAt(ln, "NSS-E-FIN-002", "unknown finance period convention '" + v + "'", "SST-FIN-PERIOD", true); else sheet.finance.hasPeriod = true; } else if (key == "discounting") { std::string v = readScalarText(); if (!financeDiscountingFromName(v, sheet.finance.discounting)) errAt(ln, "NSS-E-FIN-003", "unknown finance discounting '" + v + "'", "SST-FIN-DISCOUNTING", true); } else { // unknown finance directive: ignore the value (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } // ---- subject block (NS-SST-0001 2.0 semantic layer) ---------------- // A subject declares identity/domain/dependencies plus repeatable nested // quantity/assumption/relation/transformation/comparison/evidence/ // explanation/todo blocks. It fills a nordshrift::semantic::Subject and is // attached to sheet.subjects. Canonical chain: Subject -> Quantity -> Unit // -> Assumption -> Relation -> Formula -> Transformation -> Result -> // ComparativeNorm -> Evidence -> Explanation -> Validation. void parseSubject() { using namespace semantic; Subject subj; int subjLine = cur().line; i++; // 'subject' if (is(Tok::Ident) || is(Tok::String)) subj.identity = take().text; if (!enterBlock()) { syncToNewline(); if (!subj.identity.empty()) sheet.subjects.push_back(std::move(subj)); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; // Scalar keys consume their own ':'; nested-block keys leave the // ':' for the sub-parser's enterBlock() (a named block like // `quantity range:` puts the name before the ':'). if (key == "domain") { if (is(Tok::Colon)) i++; subj.domain = readScalarText(); } else if (key == "depends" || key == "dependencies") { if (is(Tok::Colon)) i++; subj.dependencies = readListOrScalar(); } else if (key == "quantity") parseQuantity(subj); else if (key == "assumption") parseAssumption(subj); else if (key == "relation") parseRelation(subj); else if (key == "transformation")parseTransformation(subj); else if (key == "comparison") parseComparison(subj); else if (key == "evidence") parseEvidence(subj); else if (key == "explanation") parseExplanation(subj); else if (key == "todo") parseTodo(subj, ln); else { if (is(Tok::Colon)) i++; (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); if (subj.identity.empty()) errAt(subjLine, "NSS-E-SUB-001", "subject block without an identity", "SST-SUB-IDENTITY", true); else sheet.subjects.push_back(std::move(subj)); } // Read an EvidenceStatus scalar with validation (default Specified). semantic::EvidenceStatus readEvidence(int ln) { semantic::EvidenceStatus st = semantic::EvidenceStatus::Specified; std::string v = readScalarText(); if (!v.empty() && !semantic::evidenceStatusFromName(v, st)) errAt(ln, "NSS-E-SUB-002", "unknown evidence status '" + v + "'", "SST-SUB-EVIDENCE", true); return st; } void parseQuantity(semantic::Subject& subj) { semantic::Quantity q; if (is(Tok::Ident) || is(Tok::String)) q.identity = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "value") q.value = readScalarText(); else if (k == "unit") q.unit = readScalarText(); else if (k == "dimension") q.dimension = readScalarText(); else if (k == "domain") q.domain = readScalarText(); else if (k == "status") q.status = readEvidence(ln); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.quantities.push_back(std::move(q)); } void parseAssumption(semantic::Subject& subj) { semantic::Assumption a; if (is(Tok::Ident) || is(Tok::String)) a.identity = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "statement") a.statement = readScalarText(); else if (k == "scope") a.scope = readScalarText(); else if (k == "source")a.source = readScalarText(); else if (k == "status")a.status = readEvidence(ln); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.assumptions.push_back(std::move(a)); } void parseRelation(semantic::Subject& subj) { semantic::Relation r; if (is(Tok::Ident) || is(Tok::String)) r.identity = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "formula") r.formula = readScalarText(); else if (k == "inputs") r.inputs = readListOrScalar(); else if (k == "outputs") r.outputs = readListOrScalar(); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.relations.push_back(std::move(r)); } void parseTransformation(semantic::Subject& subj) { semantic::Transformation t; if (is(Tok::Ident) || is(Tok::String)) t.identity = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "source") t.source = readScalarText(); else if (k == "operation") t.operation = readScalarText(); else if (k == "parameters") t.parameters = readScalarText(); else if (k == "destination") t.destination = readScalarText(); else if (k == "approximate") t.approximate = parseBool(readScalarText(), false); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.transformations.push_back(std::move(t)); } void parseComparison(semantic::Subject& subj) { semantic::ComparativeNorm c; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "prior") c.prior_subject = readScalarText(); else if (k == "current") c.current_subject = readScalarText(); else if (k == "reference") c.reference_subject = readScalarText(); else if (k == "norm") c.norm = readScalarText(); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.comparisons.push_back(std::move(c)); } void parseEvidence(semantic::Subject& subj) { semantic::Evidence e; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "status") e.status = readEvidence(ln); else if (k == "source")e.source = readScalarText(); else if (k == "note") e.note = readScalarText(); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.evidence.push_back(std::move(e)); } void parseExplanation(semantic::Subject& subj) { semantic::Explanation ex; if (is(Tok::Ident) || is(Tok::String)) ex.subject = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "steps") ex.steps = readListOrScalar(); else if (k == "step") { for (auto& s : readListOrScalar()) ex.steps.push_back(s); } else if (k == "subject") ex.subject = readScalarText(); else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } subj.explanations.push_back(std::move(ex)); } void parseTodo(semantic::Subject& subj, int todoLine) { semantic::Todo td; td.subject = subj.identity; if (is(Tok::Ident) || is(Tok::String)) td.identity = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string k = cur().text; i++; if (is(Tok::Colon)) i++; if (k == "priority") { std::string v = readScalarText(); td.priority = v.empty()?0:std::stoi(v); } else if (k == "depends" || k == "dependencies") td.dependencies = readListOrScalar(); else if (k == "preconditions") td.preconditions = readScalarText(); else if (k == "action") td.action = readScalarText(); else if (k == "expected" || k == "expected-result") td.expected_result = readScalarText(); else if (k == "validation") td.validation = readScalarText(); else if (k == "status") { std::string v = readScalarText(); if (!v.empty() && !semantic::workStatusFromName(v, td.status)) errAt(ln, "NSS-E-SUB-003", "unknown work status '" + v + "'", "SST-SUB-WORKSTATUS", true); } else { (void)readScalarText(); } if (is(Tok::Newline)) i++; } exitBlock(); } (void)todoLine; subj.workplan.push_back(std::move(td)); } // ---- inline rule block (§8.6) -------------------------------------- void parseRuleBlock() { RuleConfig rc; rc.line = cur().line; i++; // 'rule' if (is(Tok::Ident)) rc.name = take().text; if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string key = cur().text; i++; if (key == "severity") { rc.severity = parseSeverity(readScalarText()); rc.hasSeverity = true; } else if (key == "config") { if (enterBlock()) { while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } std::string k = take().text; std::string v = readScalarText(); rc.config[k] = v; if (is(Tok::Newline)) i++; } exitBlock(); } continue; } if (is(Tok::Newline)) i++; } exitBlock(); } sheet.ruleBlocks.push_back(rc); } // ---- profile (§XIII) ----------------------------------------------- void parseProfile() { Profile pf; pf.line = cur().line; i++; // 'profile' if (is(Tok::Ident)) pf.name = take().text; pf.overlay = std::make_shared(); if (enterBlock()) { // optional 'inherits ' if (isIdent("inherits")) { i++; if (is(Tok::Ident)) { pf.inherits = take().text; pf.hasInherits = true; } // PROF-02: a second inherits (or a list) is multiple-parent if (is(Tok::Comma) || is(Tok::Ident)) errAt(pf.line, "NSS-E-0110", "profile '" + pf.name + "' declares multiple parents", "PROF-02"); if (is(Tok::Newline)) i++; } // nested sections override into the overlay sheet Sheet* saved = &sheet; // Parse nested sections directly into pf.overlay by temporarily // retargeting: simplest is to parse into local structures. while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } const std::string& kw = cur().text; if (kw == "pipeline") parsePipeline(pf.overlay->pipeline); else if (kw == "target") { parseTargetInto(pf.overlay->target); } else if (kw == "guards") parseGuards(pf.overlay->guards); else if (kw == "derive") parseDerive(pf.overlay->derive); else { syncToNewline(); } } (void)saved; exitBlock(); } // PROF-03 circular inheritance is checked during resolution, not here. sheet.profiles.push_back(pf); } // target parser variant writing into an arbitrary Target (for profiles) void parseTargetInto(Target& tg) { tg.present = true; tg.line = cur().line; i++; if (!enterBlock()) { syncToNewline(); return; } while (!atBlockEnd()) { if (is(Tok::Newline)) { i++; continue; } if (!is(Tok::Ident)) { syncToNewline(); continue; } int ln = cur().line; std::string key = cur().text; i++; if (key == "root") { tg.root = readScalarText(); tg.hasRoot = true; } else if (key == "layout") { tg.layout = parseLayout(readScalarText()); tg.hasLayout = true; } else if (key == "java-version") { std::string v = readScalarText(); tg.javaVersion = v.empty()?0:std::stoi(v); tg.hasJavaVersion = true; if (tg.javaVersion && tg.javaVersion < 17) errAt(ln, "NSS-E-0040", "target.java-version must be >= 17", "TGT-01"); } else if (key == "overwrite") tg.overwrite = parseBool(readScalarText(), true); else if (key == "source-map") tg.sourceMap = parseBool(readScalarText(), true); else if (key == "optimize") tg.optimize = parseBool(readScalarText(), false); else if (key == "clean") tg.clean = parseBool(readScalarText(), false); else if (key == "target-language") { std::string v = readScalarText(); tg.language = (v=="sleela")?TargetLang::Sleela:(v=="c")?TargetLang::C:TargetLang::Java; } if (is(Tok::Newline)) i++; } exitBlock(); } }; } // namespace // --------------------------------------------------------------------------- // Closed network object series mappings (SST.NETWORK.md / NS-SST-NET-0001). // --------------------------------------------------------------------------- bool networkObjectFromName(const std::string& s, NetworkObject& out) { if (s == "Endpoint") { out = NetworkObject::Endpoint; return true; } if (s == "NIC") { out = NetworkObject::NIC; return true; } if (s == "Link") { out = NetworkObject::Link; return true; } if (s == "Packet") { out = NetworkObject::Packet; return true; } if (s == "Queue") { out = NetworkObject::Queue; return true; } if (s == "Switch") { out = NetworkObject::Switch; return true; } if (s == "Router") { out = NetworkObject::Router; return true; } if (s == "Fabric") { out = NetworkObject::Fabric; return true; } if (s == "Listener") { out = NetworkObject::Listener; return true; } if (s == "Connector") { out = NetworkObject::Connector; return true; } if (s == "Gateway") { out = NetworkObject::Gateway; return true; } if (s == "LoadBalancer") { out = NetworkObject::LoadBalancer; return true; } if (s == "Service") { out = NetworkObject::Service; return true; } if (s == "TLS") { out = NetworkObject::TLS; return true; } if (s == "DNS") { out = NetworkObject::DNS; return true; } return false; } bool networkTransportFromName(const std::string& s, NetworkTransport& out) { if (s == "tcp") { out = NetworkTransport::TCP; return true; } if (s == "udp") { out = NetworkTransport::UDP; return true; } if (s == "tls") { out = NetworkTransport::TLS; return true; } if (s == "quic") { out = NetworkTransport::QUIC; return true; } return false; } bool networkAddressFamilyFromName(const std::string& s, NetworkAddressFamily& out) { if (s == "ipv4") { out = NetworkAddressFamily::IPv4; return true; } if (s == "ipv6") { out = NetworkAddressFamily::IPv6; return true; } if (s == "dual") { out = NetworkAddressFamily::Dual; return true; } return false; } const char* networkObjectName(NetworkObject o) { switch (o) { case NetworkObject::Endpoint: return "Endpoint"; case NetworkObject::NIC: return "NIC"; case NetworkObject::Link: return "Link"; case NetworkObject::Packet: return "Packet"; case NetworkObject::Queue: return "Queue"; case NetworkObject::Switch: return "Switch"; case NetworkObject::Router: return "Router"; case NetworkObject::Fabric: return "Fabric"; case NetworkObject::Listener: return "Listener"; case NetworkObject::Connector: return "Connector"; case NetworkObject::Gateway: return "Gateway"; case NetworkObject::LoadBalancer: return "LoadBalancer"; case NetworkObject::Service: return "Service"; case NetworkObject::TLS: return "TLS"; case NetworkObject::DNS: return "DNS"; } return "?"; } const char* networkTransportName(NetworkTransport t) { switch (t) { case NetworkTransport::TCP: return "tcp"; case NetworkTransport::UDP: return "udp"; case NetworkTransport::TLS: return "tls"; case NetworkTransport::QUIC: return "quic"; } return "?"; } const char* networkAddressFamilyName(NetworkAddressFamily a) { switch (a) { case NetworkAddressFamily::IPv4: return "ipv4"; case NetworkAddressFamily::IPv6: return "ipv6"; case NetworkAddressFamily::Dual: return "dual"; } return "?"; } // --------------------------------------------------------------------------- // Closed finance object series mappings (SST.FINANCIAL.md). // --------------------------------------------------------------------------- bool financeObjectFromName(const std::string& s, FinanceObject& out) { if (s == "FutureValue") { out = FinanceObject::FutureValue; return true; } if (s == "PresentValue") { out = FinanceObject::PresentValue; return true; } if (s == "AnnuityPresent") { out = FinanceObject::AnnuityPresent; return true; } if (s == "AnnuityFuture") { out = FinanceObject::AnnuityFuture; return true; } if (s == "NetPresentValue") { out = FinanceObject::NetPresentValue; return true; } if (s == "BondPrice") { out = FinanceObject::BondPrice; return true; } if (s == "CAPM") { out = FinanceObject::CAPM; return true; } if (s == "WACC") { out = FinanceObject::WACC; return true; } if (s == "Determinant2x2") { out = FinanceObject::Determinant2x2; return true; } if (s == "LinearSolve2x2") { out = FinanceObject::LinearSolve2x2; return true; } if (s == "QuadraticEquation") { out = FinanceObject::QuadraticEquation; return true; } if (s == "Ratio") { out = FinanceObject::Ratio; return true; } return false; } bool financePeriodFromName(const std::string& s, FinancePeriodConvention& out) { if (s == "annual") { out = FinancePeriodConvention::Annual; return true; } if (s == "semi-annual") { out = FinancePeriodConvention::SemiAnnual; return true; } if (s == "quarterly") { out = FinancePeriodConvention::Quarterly; return true; } if (s == "monthly") { out = FinancePeriodConvention::Monthly; return true; } if (s == "continuous") { out = FinancePeriodConvention::Continuous; return true; } return false; } bool financeDiscountingFromName(const std::string& s, FinanceDiscounting& out) { if (s == "discrete") { out = FinanceDiscounting::Discrete; return true; } if (s == "continuous") { out = FinanceDiscounting::Continuous; return true; } return false; } const char* financeObjectName(FinanceObject o) { switch (o) { case FinanceObject::FutureValue: return "FutureValue"; case FinanceObject::PresentValue: return "PresentValue"; case FinanceObject::AnnuityPresent: return "AnnuityPresent"; case FinanceObject::AnnuityFuture: return "AnnuityFuture"; case FinanceObject::NetPresentValue: return "NetPresentValue"; case FinanceObject::BondPrice: return "BondPrice"; case FinanceObject::CAPM: return "CAPM"; case FinanceObject::WACC: return "WACC"; case FinanceObject::Determinant2x2: return "Determinant2x2"; case FinanceObject::LinearSolve2x2: return "LinearSolve2x2"; case FinanceObject::QuadraticEquation: return "QuadraticEquation"; case FinanceObject::Ratio: return "Ratio"; } return "?"; } const char* financePeriodName(FinancePeriodConvention p) { switch (p) { case FinancePeriodConvention::Annual: return "annual"; case FinancePeriodConvention::SemiAnnual: return "semi-annual"; case FinancePeriodConvention::Quarterly: return "quarterly"; case FinancePeriodConvention::Monthly: return "monthly"; case FinancePeriodConvention::Continuous: return "continuous"; } return "?"; } const char* financeDiscountingName(FinanceDiscounting d) { switch (d) { case FinanceDiscounting::Discrete: return "discrete"; case FinanceDiscounting::Continuous: return "continuous"; } return "?"; } // ---- Munction reach enum <-> name mappings (1.3) -------------------------- bool reachVerbFromName(const std::string& s, ReachVerb& out) { if (s == "start") { out = ReachVerb::Start; return true; } if (s == "connect") { out = ReachVerb::Connect; return true; } if (s == "open") { out = ReachVerb::Open; return true; } if (s == "enable") { out = ReachVerb::Enable; return true; } if (s == "send") { out = ReachVerb::Send; return true; } if (s == "thatch") { out = ReachVerb::Thatch; return true; } if (s == "consume") { out = ReachVerb::Consume; return true; } if (s == "observe") { out = ReachVerb::Observe; return true; } if (s == "propagate") { out = ReachVerb::Propagate; return true; } if (s == "latch") { out = ReachVerb::Latch; return true; } if (s == "contain") { out = ReachVerb::Contain; return true; } if (s == "close") { out = ReachVerb::Close; return true; } if (s == "closeWithReceipt") { out = ReachVerb::CloseWithReceipt; return true; } if (s == "abort") { out = ReachVerb::Abort; return true; } return false; } const char* reachVerbName(ReachVerb v) { switch (v) { case ReachVerb::Start: return "start"; case ReachVerb::Connect: return "connect"; case ReachVerb::Open: return "open"; case ReachVerb::Enable: return "enable"; case ReachVerb::Send: return "send"; case ReachVerb::Thatch: return "thatch"; case ReachVerb::Consume: return "consume"; case ReachVerb::Observe: return "observe"; case ReachVerb::Propagate: return "propagate"; case ReachVerb::Latch: return "latch"; case ReachVerb::Contain: return "contain"; case ReachVerb::Close: return "close"; case ReachVerb::CloseWithReceipt: return "closeWithReceipt"; case ReachVerb::Abort: return "abort"; } return "?"; } bool reachChannelFromName(const std::string& s, ReachChannel& out) { if (s == "pipe") { out = ReachChannel::Pipe; return true; } if (s == "file") { out = ReachChannel::File; return true; } if (s == "tcp") { out = ReachChannel::Tcp; return true; } if (s == "http") { out = ReachChannel::Http; return true; } if (s == "sdps") { out = ReachChannel::Sdps; return true; } if (s == "crypto") { out = ReachChannel::Crypto; return true; } return false; } const char* reachChannelName(ReachChannel c) { switch (c) { case ReachChannel::Pipe: return "pipe"; case ReachChannel::File: return "file"; case ReachChannel::Tcp: return "tcp"; case ReachChannel::Http: return "http"; case ReachChannel::Sdps: return "sdps"; case ReachChannel::Crypto: return "crypto"; } return "?"; } // ---- Synchro measure enum <-> name mappings (1.3) ------------------------- bool measureMetricFromName(const std::string& s, MeasureMetric& out) { if (s == "sent") { out = MeasureMetric::Sent; return true; } if (s == "received") { out = MeasureMetric::Received; return true; } if (s == "loss") { out = MeasureMetric::Loss; return true; } if (s == "mean") { out = MeasureMetric::Mean; return true; } if (s == "min") { out = MeasureMetric::Min; return true; } if (s == "max") { out = MeasureMetric::Max; return true; } if (s == "p95") { out = MeasureMetric::P95; return true; } if (s == "report") { out = MeasureMetric::Report; return true; } return false; } const char* measureMetricName(MeasureMetric m) { switch (m) { case MeasureMetric::Sent: return "sent"; case MeasureMetric::Received: return "received"; case MeasureMetric::Loss: return "loss"; case MeasureMetric::Mean: return "mean"; case MeasureMetric::Min: return "min"; case MeasureMetric::Max: return "max"; case MeasureMetric::P95: return "p95"; case MeasureMetric::Report: return "report"; } return "?"; } Sheet parseSheet(const std::vector& toks, const std::string& file, DiagnosticBag& diags) { Parser p(toks, file, diags); return p.run(); } } // namespace nordshrift