@pineforge/codegen-pyodide 1.2.0 → 1.4.0

package/pineforge_codegen/codegen/security.py

@@ -194,13 +194,19 @@ class SecurityEmitter:
         chart timeframe — its evaluator result is never read. Any other
         timeframe registration cannot compute is refused: it used to register
         the chart timeframe, silently.
+
+        Every timeframe string resolved from the script -- the literal, a
+        constant, a helper parameter's argument, a ternary or switch arm --
+        is a Pine timeframe (``_refuse_invalid_security_tf``).
         """
         if isinstance(tf_node, StringLiteral):
+            self._refuse_invalid_security_tf(tf_node.value, tf_node)
             return tf_node.value, None
         if isinstance(tf_node, SwitchStmt):
             # Keep diagnostics from the registration-time switch renderer
             # visible; the broad expression fallback below intentionally
             # catches ordinary unresolved expressions.
+            self._check_security_tf_arms(tf_node, set())
             return None, self._security_tf_runtime_expr(tf_node)
         if isinstance(tf_node, Identifier):
             name = tf_node.name
@@ -209,6 +215,7 @@ class SecurityEmitter:
             if (name in self._known_vars and name not in self._input_backed_vars
                     and not self._known_var_is_lexically_shadowed(name)
                     and isinstance(self._known_vars[name], str)):
+                self._refuse_invalid_security_tf(self._known_vars[name], tf_node)
                 return self._known_vars[name], None
             if (name in self._input_backed_vars
                     and name in self._input_var_to_call
@@ -216,6 +223,7 @@ class SecurityEmitter:
                 return None, self._visit_expr(self._input_var_to_call[name])
             global_expr_map = getattr(self.ctx, "global_expr_map", {}) or {}
             if name in global_expr_map:
+                self._check_security_tf_arms(global_expr_map[name], {name})
                 expanded = self._security_tf_runtime_expr(
                     global_expr_map[name], resolving={name}
                 )
@@ -238,6 +246,7 @@ class SecurityEmitter:
             self._security_tf_unresolved(tf_node, f"timeframe '{name}'")
         # any other expression — visit if it resolves at class scope
         try:
+            self._check_security_tf_arms(tf_node, set())
             expanded = self._security_tf_runtime_expr(tf_node)
             return None, expanded if expanded is not None else self._visit_expr(tf_node)
         except CompileError:
@@ -245,6 +254,45 @@ class SecurityEmitter:
         except Exception:
             self._security_tf_unresolved(tf_node, "timeframe expression")
 
+    def _refuse_invalid_security_tf(self, value: str, node) -> None:
+        """Refuse a timeframe string resolved from the script that is not a
+        Pine timeframe, with the support checker's diagnostic for the same
+        string written in the call (``invalid_tf_literal``): it reaches the
+        C++ registration. An empty string registers the chart's timeframe."""
+        if not value:
+            return
+        from ..support_checker import invalid_tf_literal
+        fn_label = ("request.security_lower_tf" if getattr(self, "_security_tf_lower", False)
+                    else "request.security")
+        refusal = invalid_tf_literal(value, fn_label)
+        if refusal is not None:
+            message, hint = refusal
+            self._codegen_error(node, message, hint=hint)
+
+    def _check_security_tf_arms(self, node, resolving: set[str]) -> None:
+        """Refuse an invalid timeframe string a registration-time timeframe
+        expression can select: the expression itself, a ternary or switch
+        arm, read through the constants and globals it names."""
+        def check(value) -> None:
+            if isinstance(value, StringLiteral):
+                self._refuse_invalid_security_tf(value.value, value)
+            elif isinstance(value, Ternary):
+                check(value.true_val)
+                check(value.false_val)
+            elif isinstance(value, SwitchStmt):
+                arms = [body for _case, body in value.cases]
+                for body in arms + ([value.default_body] if value.default_body else []):
+                    if len(body) == 1 and isinstance(body[0], ExprStmt):
+                        check(self._substitute_tf_input_reads(body[0].expr, resolving))
+
+        check(node if isinstance(node, SwitchStmt)
+              else self._substitute_tf_input_reads(node, resolving))
+
+    def _security_tf_literal(self, tf: str) -> str:
+        """A timeframe string as the C++ string literal registration and the
+        evaluator's ``timeframe.*`` reads spell it."""
+        return f'"{self._cpp_string_escape(tf)}"'
+
     def _security_tf_unresolved(self, tf_node, what: str) -> None:
         """Refuse a request.security timeframe registration cannot compute."""
         self._codegen_error(
@@ -1981,8 +2029,9 @@ class SecurityEmitter:
         parts = request.annotations[RECORDED_KEY_ANNOTATION]
         tail = (f"|{parts['field']}|{parts['period']}|gaps_{parts['gaps']}"
                 f"|lookahead_{parts['lookahead']}")
-        return (f'(std::string("{parts["fn"]}|") + {self._visit_expr(request.args[0])} + '
-                f'std::string("{tail}"))')
+        fn = self._cpp_string_escape(parts["fn"])
+        return (f'(std::string("{fn}|") + {self._visit_expr(request.args[0])} + '
+                f'std::string("{self._cpp_string_escape(tail)}"))')
 
     def _recorded_sites(self) -> dict[int, int]:
         """Each recorded request's index N: ``_pf_recorded`` sets its
@@ -2606,7 +2655,7 @@ class SecurityEmitter:
 
     def _security_expr_hist_series_names(self, sec_id: int) -> list[str]:
         names = []
-        for (sid, _node_id), meta in sorted(self._security_expr_hist_by_node.items()):
+        for (sid, _node_id), meta in self._security_expr_hist_by_node.items():
             if sid == sec_id:
                 names.append(meta["name"])
         return names
@@ -2709,7 +2758,7 @@ class SecurityEmitter:
         """C++ expression for the timeframe of a request.security evaluator."""
         info = self._security_eval_info[sec_id]
         if info.get("tf"):
-            return f'"{info["tf"]}"'
+            return self._security_tf_literal(info["tf"])
         if info.get("tf_expr"):
             return info["tf_expr"]
         return "input_tf_"
@@ -2775,7 +2824,7 @@ class SecurityEmitter:
             if series_name in self._security_string_series
             else "_security_helper_series_"
         )
-        return f'{store}["{series_name}"]'
+        return f'{store}["{self._cpp_string_escape(series_name)}"]'
 
     def _security_helper_var_state_type(self, stmt: VarDecl) -> str:
         """The type family of a helper ``var`` whose declaration reads
@@ -6377,7 +6426,7 @@ class SecurityEmitter:
         if column is not None and self._security_foreign(sec_id):
             # request.footprint(...) of another symbol: the delta its feed
             # records for the requested bar (the value its delta() reads).
-            return f'_pf_symbol_column({sec_id}, "{column}")'
+            return f'_pf_symbol_column({sec_id}, "{self._cpp_string_escape(column)}")'
 
         if resolving is None:
             resolving = set()
@@ -7178,7 +7227,8 @@ class SecurityEmitter:
                 "request.security: a Heikin-Ashi request inside another request's "
                 "expression reads that request's Heikin-Ashi bars, which PineForge "
                 "does not build")
-            return (f'([&]() -> {cpp_t} {{ pine_runtime_error(std::string("{message}")); '
+            line = expr_node.loc.line if expr_node.loc else 1
+            return (f'([&]() -> {cpp_t} {{ _PF_UNSUPPORTED_STOP("nested_heikinashi_request", {line}, "{message}"); '
                     f"return {na_value}; }}())")
 
         site = self._get_ta_site(expr_node)
@@ -7837,8 +7887,9 @@ class SecurityEmitter:
     def _security_variant_order_key(self, signature: tuple, binding_stack) -> tuple:
         """The order of a TA site's requested-context variants (``_v0``,
         ``_v1``, ...): where each argument binding's value is written in the
-        source, then the signature. The signature names a bound node by its
-        ``id()``, so ordering by its ``repr`` followed memory addresses, and
+        source, then the signature's stable scope snapshot, preserving
+        traversal order at ties. The signature names a bound node by its
+        ``id()``, so ordering by its raw ``repr`` followed memory addresses, and
         the same script could number its variants differently from run to
         run or between CPython and Pyodide."""
         frames = []
@@ -7860,4 +7911,9 @@ class SecurityEmitter:
                 frames.append(("arguments", tuple(items)))
             else:
                 frames.append(("locals", tuple(sorted(frame.keys()))))
-        return tuple(frames), repr(signature)
+        def stable_part(value):
+            if isinstance(value, tuple):
+                return tuple(stable_part(item) for item in value)
+            return 0 if isinstance(value, int) else value
+
+        return tuple(frames), repr(stable_part(signature))

package/pineforge_codegen/codegen/tables.py

@@ -545,6 +545,18 @@ ORDER_DIRECTION_MAP = {
     "descending": 'std::string("descending")',
 }
 
+NAME_ECHO_STRING_MEMBERS = {
+    "currency": frozenset({
+        "AED", "ARS", "AUD", "BDT", "BHD", "BRL", "BTC", "CAD", "CHF", "CLP",
+        "CNY", "COP", "CZK", "DKK", "EGP", "ETH", "EUR", "GBP", "HKD", "HUF",
+        "IDR", "ILS", "INR", "ISK", "JPY", "KES", "KRW", "KWD", "LKR", "MAD",
+        "MXN", "MYR", "NGN", "NOK", "NONE", "NZD", "PEN", "PHP", "PKR", "PLN",
+        "QAR", "RON", "RSD", "RUB", "SAR", "SEK", "SGD", "THB", "TND", "TRY",
+        "TWD", "USD", "USDT", "VES", "VND", "ZAR",
+    }),
+    "format": frozenset({"inherit", "price", "volume", "percent", "mintick"}),
+}
+
 
 # ---------------------------------------------------------------------------
 # Array / Map / Matrix method dispatch
@@ -553,6 +565,7 @@ ORDER_DIRECTION_MAP = {
 
 def _checked_array_index_prelude(
     *,
+    method: str,
     normalize_negative: bool = True,
     allow_size: bool = False,
     name: str = "index",
@@ -590,18 +603,18 @@ def _checked_array_index_prelude(
         f"using {raw_type}=std::decay_t<decltype({raw_value})>; "
         f"if constexpr(!std::is_same_v<{raw_type},bool>) {{ "
         f"if(is_na({raw_value})) "
-        "pine_runtime_error(std::string(\"Index na is out of bounds. Array size is \")+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index na is out of bounds. Array size is ")+ '
         "std::to_string((int64_t)__pf_array.size())); } "
         f"if constexpr(std::is_floating_point_v<{raw_type}>) {{ "
         f"if(!std::isfinite({raw_value})) {{ "
         f"std::string {raw_text}={raw_value}>0?\"inf\":\"-inf\"; "
-        f"pine_runtime_error(std::string(\"Index \")+{raw_text}+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index ")+{raw_text}+'
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
         f"long double {raw_wide}=(long double){raw_value}; "
         f"if({raw_wide}<(long double)std::numeric_limits<int64_t>::min()||"
         f"{raw_wide}>(long double)std::numeric_limits<int64_t>::max()) "
-        "pine_runtime_error(std::string(\"Index \")+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index ")+ '
         f"std::to_string((double){raw_value})+"
         "\" is out of bounds. Array size is \"+"
         "std::to_string((int64_t)__pf_array.size())); } "
@@ -609,12 +622,12 @@ def _checked_array_index_prelude(
         f"int64_t {size}=(int64_t)__pf_array.size(); "
         f"int64_t {checked}={checked_index}; "
         f"if({checked}<0||{checked}{upper}{size}) "
-        f"pine_runtime_error(std::string(\"Index \")+std::to_string({raw})+"
+        f'_PF_ARRAY_STOP("index_out_of_bounds", "{method}", std::string("Index ")+std::to_string({raw})+'
         f"\" is out of bounds. Array size is \"+std::to_string({size})); "
     )
 
 
-def _checked_array_range_prelude(*, reject_inverted: bool = True) -> str:
+def _checked_array_range_prelude(*, method: str, reject_inverted: bool = True) -> str:
     """Validate the half-open ``[index_from, index_to)`` range of fill/slice.
 
     Both endpoints are checked with ``allow_size`` (``index_to`` is exclusive,
@@ -625,14 +638,14 @@ def _checked_array_range_prelude(*, reject_inverted: bool = True) -> str:
     """
     return (
         _checked_array_index_prelude(
-            normalize_negative=False, allow_size=True, name="index_from"
+            method=method, normalize_negative=False, allow_size=True, name="index_from"
         )
         + _checked_array_index_prelude(
-            normalize_negative=False, allow_size=True, name="index_to"
+            method=method, normalize_negative=False, allow_size=True, name="index_to"
         )
         + (
             "if(__pf_array_index_from>__pf_array_index_to) "
-            "pine_runtime_error(\"Index 'from' should be less than index 'to'.\"); "
+            '_PF_ARRAY_STOP("slice_range_inverted", "slice", "Index \'from\' should be less than index \'to\'."); '
             if reject_inverted else ""
         )
     )
@@ -644,7 +657,7 @@ def _checked_array_insert(a: str, args: list[str], normalize_negative: bool = Tr
     ``index == size`` appends, so the bound is ``index <= size``; a negative
     index is end-relative, exactly as for ``get``/``set``/``remove``.
     """
-    check = _checked_array_index_prelude(allow_size=True,
+    check = _checked_array_index_prelude(method="insert", allow_size=True,
                                          normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
@@ -659,7 +672,7 @@ def _checked_array_insert(a: str, args: list[str], normalize_negative: bool = Tr
 
 def _checked_array_fill_range(a: str, args: list[str]) -> str:
     """``array.fill(id, value, index_from, index_to)`` — bounded range fill."""
-    check = _checked_array_range_prelude(reject_inverted=False)
+    check = _checked_array_range_prelude(method="fill", reject_inverted=False)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_array_value){ "
@@ -679,7 +692,7 @@ def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
     ``result_type`` stays caller-supplied so the typed method lane keeps
     emitting the receiver's own element type; only the bounds checks are new.
     """
-    check = _checked_array_range_prelude()
+    check = _checked_array_range_prelude(method="slice")
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_from_value){ "
@@ -692,7 +705,7 @@ def checked_array_slice(a: str, args: list[str], *, result_type: str) -> str:
 
 
 def _checked_array_get(a: str, args: list[str], normalize_negative: bool = True) -> str:
-    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
+    check = _checked_array_index_prelude(method="get", normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array)->decltype(auto){ "
         "return [&](auto&& __pf_raw_index_value)->decltype(auto){ "
@@ -707,7 +720,7 @@ def _checked_array_get(a: str, args: list[str], normalize_negative: bool = True)
 
 
 def _checked_array_set(a: str, args: list[str], normalize_negative: bool = True) -> str:
-    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
+    check = _checked_array_index_prelude(method="set", normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -719,7 +732,7 @@ def _checked_array_set(a: str, args: list[str], normalize_negative: bool = True)
 
 
 def _checked_array_remove(a: str, args: list[str], normalize_negative: bool = True) -> str:
-    check = _checked_array_index_prelude(normalize_negative=normalize_negative)
+    check = _checked_array_index_prelude(method="remove", normalize_negative=normalize_negative)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -738,7 +751,7 @@ def _checked_array_end_get(a: str, method: str) -> str:
     access = "front" if method == "first" else "back"
     return (
         "[&](auto&& __pf_array)->decltype(auto){ "
-        f"if(__pf_array.empty()) pine_runtime_error(\"Cannot use {method}() "
+        f'if(__pf_array.empty()) _PF_ARRAY_STOP("empty_array_access", "{method}", "Cannot use {method}() '
         "if array is empty.\"); "
         "if constexpr(std::is_lvalue_reference_v<decltype(__pf_array)>) "
         f"return (__pf_array.{access}()); "
@@ -758,7 +771,7 @@ def _checked_array_end_remove(a: str, method: str) -> str:
     )
     return (
         "[&](auto&& __pf_array){ "
-        f"if(__pf_array.empty()) pine_runtime_error(\"Cannot use {method}() "
+        f'if(__pf_array.empty()) _PF_ARRAY_STOP("empty_array_access", "{method}", "Cannot use {method}() '
         "if array is empty.\"); "
         "using __pf_array_value_type=typename "
         "std::decay_t<decltype(__pf_array)>::value_type; "
@@ -769,7 +782,7 @@ def _checked_array_end_remove(a: str, method: str) -> str:
 
 def _checked_array_percentrank(a: str, args: list[str]) -> str:
     """Preserve degenerate results, then reject invalid PercentRank indices."""
-    check = _checked_array_index_prelude(normalize_negative=False)
+    check = _checked_array_index_prelude(method="percentrank", normalize_negative=False)
     return (
         "[&](auto&& __pf_array){ "
         "return [&](auto&& __pf_raw_index_value){ "
@@ -810,7 +823,7 @@ ARRAY_METHODS = {
     "size":      lambda a, args: f"(double){a}.size()",
     "clear":     lambda a, args: f"{a}.clear()",
     "fill":      lambda a, args: f"std::fill({a}.begin(), {a}.end(), {args[0]})" if len(args) == 1
-                                 else _checked_array_fill_range(a, args),
+                                 else _checked_array_fill_range(a, args + [f"(int){a}.size()"] if len(args) == 2 else args),
     "includes":  lambda a, args: f"(std::find({a}.begin(), {a}.end(), {args[0]}) != {a}.end())",
     "indexof":   lambda a, args: f"[&](){{ auto __pf_it=std::find({a}.begin(),{a}.end(),{args[0]}); return __pf_it!={a}.end()?(double)(__pf_it-{a}.begin()):-1.0; }}()",
     "lastindexof": lambda a, args: f"[&](){{ for(int __pf_i=(int){a}.size()-1;__pf_i>=0;__pf_i--)if({a}[__pf_i]=={args[0]})return(double)__pf_i; return -1.0; }}()",
@@ -888,6 +901,9 @@ CHECKED_ARRAY_METHOD_KWARGS: dict[str, list[str]] = {
     "last": [],
     "pop": [],
     "shift": [],
+    "sort": ["order"],
+    "indexof": ["value"],
+    "unshift": ["value"],
 }
 
 MAP_METHODS = {
@@ -942,10 +958,109 @@ def _matrix_add_col(m: str, args: list) -> str:
     raise IndexError("matrix.add_col")
 
 
-# Keyword parameter order for matrix methods (Pine v6); used by ``_merge_kwargs``.
+def _matrix_sum(receiver: str, arguments: list[str]) -> str:
+    """Use the runtime's exposed Eigen arithmetic for matrix/scalar sums."""
+    if not arguments:
+        return f"{receiver}.sum()"
+    if len(arguments) != 1:
+        raise IndexError("matrix.sum")
+    return (
+        "([](const auto& _pf_sum_left, const auto& _pf_sum_right) { "
+        "auto _pf_sum_result = _pf_sum_left.copy(); "
+        "if constexpr (std::is_arithmetic_v<std::decay_t<decltype(_pf_sum_right)>>) { "
+        "_pf_sum_result.data().array() += _pf_sum_right; "
+        "} else { "
+        "if (_pf_sum_left.rows() != _pf_sum_right.rows() || "
+        "_pf_sum_left.columns() != _pf_sum_right.columns()) "
+        'throw std::runtime_error("Cannot sum matrices with different dimensions."); '
+        "_pf_sum_result.data() += _pf_sum_right.data(); "
+        "} return _pf_sum_result; "
+        f"}}({receiver}, {arguments[0]}))"
+    )
+
+
+def _matrix_submatrix(receiver: str, arguments: list[str]) -> str:
+    if len(arguments) > 4:
+        raise IndexError("matrix.submatrix")
+    if len(arguments) == 4 and all(argument is not None for argument in arguments):
+        return f"{receiver}.submatrix({', '.join(_matrix_int_arg(argument) for argument in arguments)})"
+    defaults = ["0", "_pf_matrix_target.rows()", "0", "_pf_matrix_target.columns()"]
+    arguments = arguments + [None] * (4 - len(arguments))
+    bounds = [argument if argument is not None else defaults[index]
+              for index, argument in enumerate(arguments)]
+    return ("[&](auto&& _pf_matrix_target) { return _pf_matrix_target.submatrix("
+            f"{', '.join(_matrix_int_arg(argument) for argument in bounds)}); }}({receiver})")
+
+
+# Parameter order of the matrix methods (Pine v6), receiver excluded: the
+# slots ``CallVisitor._collection_arg_nodes`` binds keyword arguments to. A
+# method absent here takes only its receiver. ``fill`` names its range
+# parameters so that a keyword one binds as a positional one does: the
+# lowering reads only ``value`` (the engine fills the whole matrix), a
+# pre-existing approximation of both spellings that the call does not refuse.
 MATRIX_METHOD_KWARGS: dict[str, list[str]] = {
-    "add_row": ["row_index", "array_id"],
-    "add_col": ["col_index", "array_id"],
+    "add_row": ["row", "array_id"],
+    "add_col": ["column", "array_id"],
+    "sort": ["column", "order"],
+    "submatrix": ["from_row", "to_row", "from_column", "to_column"],
+    "sum": ["id2"],
+    "diff": ["id2"],
+    "mult": ["id2"],
+    "get": ["row", "column"],
+    "set": ["row", "column", "value"],
+    "fill": ["value", "from_row", "to_row", "from_column", "to_column"],
+    "row": ["row"],
+    "col": ["column"],
+    "remove_row": ["row"],
+    "remove_col": ["column"],
+    "swap_rows": ["row1", "row2"],
+    "swap_columns": ["column1", "column2"],
+    "reshape": ["rows", "columns"],
+    "concat": ["id2", "vertical"],
+    "pow": ["power"],
+    "kron": ["id2"],
+}
+
+# Keyword spellings an earlier build bound that Pine's reference does not
+# name; they keep binding to the same slot.
+MATRIX_METHOD_KWARG_ALIASES: dict[str, dict[str, str]] = {
+    "add_row": {"row_index": "row"},
+    "add_col": {"col_index": "column"},
+}
+
+# The receiver's own keyword in the namespace form (``matrix.diff(id1=m, ...)``).
+MATRIX_RECEIVER_KEYWORD: dict[str, str] = {
+    "sum": "id1", "diff": "id1", "mult": "id1", "concat": "id1", "kron": "id1",
+}
+
+
+def _matrix_functional_receiver(method: str, node):
+    """The receiver node of ``matrix.<method>(...)``: its first positional
+    argument, else its keyword."""
+    return node.args[0] if node.args else node.kwargs.get(
+        MATRIX_RECEIVER_KEYWORD.get(method, "id"))
+
+
+# The optional parameters of the collection methods whose keywords bind by
+# position, and what a gap left before one stands for when only a later
+# keyword is written (``m.sort(order = order.descending)`` leaves ``column``
+# open): a number is Pine's default, ``None`` an omitted argument the method's
+# template defaults from the receiver's own extent (``_matrix_submatrix``'s
+# ``to_row`` / ``to_column``, the defaulted ``add_row`` / ``add_col`` of
+# ``TypeInferer._matrix_method_expr``). A parameter that is not listed is
+# required: a gap before it is refused.
+MATRIX_OPTIONAL_PARAMS: dict[str, dict[str, int | None]] = {
+    "sort": {"column": 0, "order": None},
+    "submatrix": {"from_row": 0, "to_row": None, "from_column": 0, "to_column": None},
+    "add_row": {"row": None, "array_id": None},
+    "add_col": {"column": None, "array_id": None},
+    "fill": {"from_row": None, "to_row": None, "from_column": None, "to_column": None},
+    "sum": {"id2": None},
+    "concat": {"vertical": None},
+}
+ARRAY_OPTIONAL_PARAMS: dict[str, dict[str, int | None]] = {
+    "fill": {"index_from": 0, "index_to": None},
+    "sort": {"order": None},
 }
 
 # Matrix mutators whose established C++ lowering returns ``void``.  A Pine
@@ -1012,17 +1127,17 @@ MATRIX_METHODS = {
     "swap_rows": lambda m, args: f"{m}.swap_rows({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "swap_columns": lambda m, args: f"{m}.swap_columns({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "copy":      lambda m, args: f"{m}.copy()",
-    "submatrix": lambda m, args: f"{m}.submatrix({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])}, {_matrix_int_arg(args[2])}, {_matrix_int_arg(args[3])})",
+    "submatrix": _matrix_submatrix,
     "reshape":   lambda m, args: f"{m}.reshape({_matrix_int_arg(args[0])}, {_matrix_int_arg(args[1])})",
     "reverse":   lambda m, args: f"{m}.reverse()",
     "transpose": lambda m, args: f"{m}.transpose()",
-    "sort":      lambda m, args: f"{m}.sort({_matrix_int_arg(args[0])}, {args[1]} != \"descending\")" if len(args)>1 else f"{m}.sort({_matrix_int_arg(args[0])})",
+    "sort":      lambda m, args: f"{m}.sort({_matrix_int_arg(args[0])}, {args[1]} != \"descending\")" if len(args)>1 else f"{m}.sort({_matrix_int_arg(args[0])})" if args else f"{m}.sort(0)",
     "concat":    lambda m, args: f"{m}.concat({args[0]}, {pine_truth_cast(args[1])})" if len(args)>1 else f"{m}.concat({args[0]}, true)",
     "avg":       lambda m, args: f"{m}.avg()",
     "min":       lambda m, args: f"{m}.min()",
     "max":       lambda m, args: f"{m}.max()",
     "mode":      lambda m, args: f"{m}.mode()",
-    "sum":       lambda m, args: f"{m}.sum()",
+    "sum":       _matrix_sum,
     "diff":      lambda m, args: f"{m}.diff({args[0]})",
     "mult":      lambda m, args: f"{m}.mult({args[0]})",
     "pow":       lambda m, args: f"{m}.pow({_matrix_int_arg(args[0])})",
@@ -1116,10 +1231,11 @@ MATH_FUNC_MAP = {
 STR_FUNC_MAP = {
     "tostring":    None,  # handled separately (already works)
     "tonumber":    lambda args: (
-        f"[&](){{ "
-        f"try {{ return std::stod({args[0]}); }} "
-        f"catch (...) {{ return na<double>(); }} "
-        f"}}()"
+        f"[&](std::string _pf_number_text){{ "
+        f"try {{ return std::stod(_pf_number_text); }} "
+        f"catch (const std::invalid_argument&) {{ return na<double>(); }} "
+        f"catch (const std::out_of_range&) {{ return na<double>(); }} "
+        f"}}(({args[0]}))"
     ),
     "length":      lambda args: f"(int){args[0]}.length()",
     "contains":    lambda args: f"({args[0]}.find({args[1]}) != std::string::npos)",

package/pineforge_codegen/codegen/tv_number_format.py

@@ -60,7 +60,7 @@ static std::string _pf_tv_decimal(double value, int min_fraction,
     char buffer[128];
     const auto converted = std::to_chars(buffer, buffer + sizeof buffer, value);
     if (converted.ec != std::errc{})
-        throw std::runtime_error("shortest-decimal conversion failed");
+        _PF_ENGINE_INVARIANT("shortest-decimal conversion failed", std::runtime_error);
     std::string spelling(buffer, converted.ptr);
     const bool negative = !spelling.empty() && spelling[0] == '-';
     if (negative) spelling.erase(0, 1);
@@ -240,7 +240,14 @@ static std::string pine_str_format_tv(
             i = end + 1;
             continue;
         }
-        const size_t index = static_cast<size_t>(std::stoul(index_text));
+        size_t index = 0;
+        for (char _pf_digit : index_text) {
+            const size_t _pf_value = static_cast<size_t>(_pf_digit - '0');
+            if (index > (std::numeric_limits<size_t>::max() - _pf_value) / 10) {
+                _PF_STRING_STOP("format_index_overflow", "stoul");
+            }
+            index = index * 10 + _pf_value;
+        }
         if (index >= args.size()) {
             result += format_string.substr(i, end - i + 1);
             i = end + 1;