pycedar 0.2.0__tar.gz → 0.2.2__tar.gz

{pycedar-0.2.0 → pycedar-0.2.2}/CHANGELOG.md

@@ -7,6 +7,73 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-09-16
+
+### Added
+
+- `benchmarks/bench.py`, which times the operations pycedar is used for so that
+  a performance change can be measured rather than assumed.
+
+### Changed
+
+- `dict.get()`, `set()`, `setdefault()`, `update()` and `get_node()` are roughly
+  twice as fast. They were declared with a fused `str`/`bytes` parameter, and
+  Cython's runtime dispatch for that cost more than the trie operation itself.
+  The parameter is now `object`, which is what `d[key]` already used; the key
+  type is still enforced by the trie underneath, so behaviour is unchanged.
+- Sentinel checks on the lookup paths compare against C constants instead of
+  building a Python tuple of Python ints on every call, which speeds up
+  `d[key]`, `key in d` and the traversals.
+
+  Measured on 20000 random keys, CPython 3.13, nanoseconds per operation:
+
+  | operation | 0.2.1 | 0.2.2 |
+  | --- | --- | --- |
+  | `d.get(key)` | 302 | 135 |
+  | `d.set(key, value)` | 242 | 108 |
+  | `d.update(key, delta)` | 235 | 112 |
+  | `d.setdefault(key)` | 290 | 129 |
+  | `d.get_node(key)` | 348 | 177 |
+  | `d[key]` | 165 | 132 |
+  | `key in d` | 133 | 123 |
+
+### Fixed
+
+- `node.traverse()` compared integers with `is`, which only worked because
+  CPython interns small integers. It now uses `!=`.
+
+## [0.2.1] - 2026-09-16
+
+### Added
+
+- `pycedar/core/cedar/README.md`, recording what was modified in the vendored
+  copy of cedar and why, that upstream's `cedarpp.h` has been unchanged since
+  2017 despite the 2022 tarball, and why that tarball was deliberately not
+  re-vendored.
+
+### Changed
+
+- Allocation failures now raise `MemoryError` instead of `RuntimeError`. The
+  vendored cedar throws `std::bad_alloc`, which Cython's `except +` maps to
+  `MemoryError`, so every allocation failure reaches Python as the same, and
+  the idiomatic, exception. `RuntimeError` is now reserved for the one
+  non-allocation case, a zero-length key reaching cedar's `update()`.
+- The vendored `cedarpp.h` adopts upstream's `clear()` layout and its
+  `STATIC_ASSERT` pragmas. Behaviour is unchanged; this removes the six
+  compiler warnings the file used to emit and reduces the delta against
+  upstream.
+
+### Fixed
+
+- An allocation failure inside `save()` or `load()` no longer terminates the
+  interpreter. The vendored cedar called `std::exit(1)` from `shrink_tail()`
+  and `open()`, killing the process and discarding buffered output; both now
+  throw. `open()` resets itself to a valid empty trie first, so the instance
+  stays usable instead of being handed back half-built.
+- `load()` no longer leaks a file descriptor every time it fails. Upstream's
+  `open()` returns `-1` from nine places without closing the file; 200 failed
+  loads leaked exactly 200 descriptors, eventually exhausting the table.
+
 ## [0.2.0] - 2026-09-16
 
 This release restores compatibility with current Python and Cython toolchains,
@@ -99,7 +166,9 @@ records; the corresponding tags were added retroactively.
 
 - Build failure with clang on macOS.
 
-[Unreleased]: https://github.com/akivajp/pycedar/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/akivajp/pycedar/compare/v0.2.2...HEAD
+[0.2.2]: https://github.com/akivajp/pycedar/compare/v0.2.1...v0.2.2
+[0.2.1]: https://github.com/akivajp/pycedar/compare/v0.2.0...v0.2.1
 [0.2.0]: https://github.com/akivajp/pycedar/compare/v0.1.3...v0.2.0
 [0.1.3]: https://github.com/akivajp/pycedar/compare/v0.1.2...v0.1.3
 [0.1.2]: https://github.com/akivajp/pycedar/compare/v0.1.1...v0.1.2

{pycedar-0.2.0 → pycedar-0.2.2}/MANIFEST.in

@@ -4,6 +4,7 @@ include CHANGELOG.md
 include pycedar/VERSION
 include pycedar/pycedar.pxd
 include pycedar/pycedar.pyx
+include pycedar/core/cedar/README.md
 include pycedar/core/cedar/AUTHORS
 include pycedar/core/cedar/BSD
 include pycedar/core/cedar/COPYING

{pycedar-0.2.0/pycedar.egg-info → pycedar-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pycedar
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python binding of cedar (implementation of efficiently-updatable double-array trie) using Cython
 Home-page: https://github.com/akivajp/pycedar
 Author: Akiva Miura
@@ -355,6 +355,12 @@ source.
 ``save()`` / ``load()`` / ``open()`` return ``0`` on success and ``-1`` on
 failure instead of raising; check the return value.
 
+Running out of memory is the exception to that rule: ``save()`` and ``load()``
+raise ``MemoryError`` rather than returning ``-1``. A failed ``load()`` leaves
+the trie **empty**, because the previous contents are released before the new
+ones are allocated. The instance stays valid and can be reused. See
+[``pycedar/core/cedar/README.md``](pycedar/core/cedar/README.md).
+
 ## Development
 
 ```shell
@@ -372,6 +378,19 @@ $ python setup.py build_ext --inplace
 
 ``./clean.sh`` removes build artifacts.
 
+### Benchmarks
+
+``benchmarks/bench.py`` times the operations pycedar is used for. Run it against
+two builds to check whether a change actually paid off:
+
+```shell
+$ python benchmarks/bench.py --label before
+$ python benchmarks/bench.py --label after
+```
+
+It uses ``rich`` for the table when that is installed, and plain text
+otherwise. ``--help`` lists the knobs.
+
 ## Releasing
 
 The version lives in a single place, [``pycedar/VERSION``](pycedar/VERSION).
@@ -393,7 +412,10 @@ LGPLv2.1 and BSD-2-Clause. See the license files bundled under
 ## Credits
 
 ``cedar`` is written by Naoki Yoshinaga. The copy vendored under
-``pycedar/core/cedar/`` carries two local modifications, documented at the top
-of [``cedarpp.h``](pycedar/core/cedar/src/cedarpp.h).
+``pycedar/core/cedar/`` carries local modifications.
+[``pycedar/core/cedar/README.md``](pycedar/core/cedar/README.md) records what
+was changed and why, why the 2022 upstream tarball was deliberately not
+re-vendored, and what has to be re-applied if anyone syncs with a newer
+release.
 
 See [CHANGELOG.md](CHANGELOG.md) for the list of contributors to each release.

{pycedar-0.2.0 → pycedar-0.2.2}/README.ja.md

@@ -314,6 +314,12 @@ cedar ネイティブの ``.dat`` 形式は、書き出したマシンのポイ
 ``save()`` / ``load()`` / ``open()`` は例外を送出せず、成功で ``0``、失敗で
 ``-1`` を返します。必ず戻り値を確認してください。
 
+唯一の例外がメモリ不足で、``save()`` と ``load()`` は ``-1`` を返すのではなく
+``MemoryError`` を送出します。``load()`` が失敗した場合、cedar は新しい配列を
+確保する前に既存の配列を解放するため、**トライは空になります**。インスタンス
+自体は有効なまま再利用できます。詳細は
+[``pycedar/core/cedar/README.md``](pycedar/core/cedar/README.md) を参照してください。
+
 ## 開発
 
 ```shell
@@ -331,6 +337,19 @@ $ python setup.py build_ext --inplace
 
 ``./clean.sh`` でビルド生成物を削除できます。
 
+### ベンチマーク
+
+``benchmarks/bench.py`` が主要な操作の実行時間を計測します。変更に効果があった
+かどうかは、2 つのビルドで実行して比較してください。
+
+```shell
+$ python benchmarks/bench.py --label before
+$ python benchmarks/bench.py --label after
+```
+
+``rich`` が入っていれば表形式で、無ければプレーンテキストで出力します。
+指定できる項目は ``--help`` を参照してください。
+
 ## リリース手順
 
 バージョンは [``pycedar/VERSION``](pycedar/VERSION) の 1 箇所のみで管理します。
@@ -352,7 +371,9 @@ BSD-2-Clause）。ライセンス文書は
 ## クレジット
 
 ``cedar`` は Naoki Yoshinaga 氏によるものです。``pycedar/core/cedar/`` に同梱
-しているコピーには 2 点のローカル変更があり、その内容は
-[``cedarpp.h``](pycedar/core/cedar/src/cedarpp.h) の冒頭に記載しています。
+しているコピーにはローカル変更があります。変更内容とその理由、2022 年の上流
+tarball をあえて取り込まなかった判断の経緯、より新しい版へ同期する際に再適用
+すべき内容は
+[``pycedar/core/cedar/README.md``](pycedar/core/cedar/README.md) に記録しています。
 
 各リリースの貢献者は [CHANGELOG.md](CHANGELOG.md) を参照してください。

{pycedar-0.2.0 → pycedar-0.2.2}/README.md

@@ -317,6 +317,12 @@ source.
 ``save()`` / ``load()`` / ``open()`` return ``0`` on success and ``-1`` on
 failure instead of raising; check the return value.
 
+Running out of memory is the exception to that rule: ``save()`` and ``load()``
+raise ``MemoryError`` rather than returning ``-1``. A failed ``load()`` leaves
+the trie **empty**, because the previous contents are released before the new
+ones are allocated. The instance stays valid and can be reused. See
+[``pycedar/core/cedar/README.md``](pycedar/core/cedar/README.md).
+
 ## Development
 
 ```shell
@@ -334,6 +340,19 @@ $ python setup.py build_ext --inplace
 
 ``./clean.sh`` removes build artifacts.
 
+### Benchmarks
+
+``benchmarks/bench.py`` times the operations pycedar is used for. Run it against
+two builds to check whether a change actually paid off:
+
+```shell
+$ python benchmarks/bench.py --label before
+$ python benchmarks/bench.py --label after
+```
+
+It uses ``rich`` for the table when that is installed, and plain text
+otherwise. ``--help`` lists the knobs.
+
 ## Releasing
 
 The version lives in a single place, [``pycedar/VERSION``](pycedar/VERSION).
@@ -355,7 +374,10 @@ LGPLv2.1 and BSD-2-Clause. See the license files bundled under
 ## Credits
 
 ``cedar`` is written by Naoki Yoshinaga. The copy vendored under
-``pycedar/core/cedar/`` carries two local modifications, documented at the top
-of [``cedarpp.h``](pycedar/core/cedar/src/cedarpp.h).
+``pycedar/core/cedar/`` carries local modifications.
+[``pycedar/core/cedar/README.md``](pycedar/core/cedar/README.md) records what
+was changed and why, why the 2022 upstream tarball was deliberately not
+re-vendored, and what has to be re-applied if anyone syncs with a newer
+release.
 
 See [CHANGELOG.md](CHANGELOG.md) for the list of contributors to each release.

pycedar-0.2.2/pycedar/VERSION

@@ -0,0 +1 @@
+0.2.2

pycedar-0.2.2/pycedar/core/cedar/README.md

@@ -0,0 +1,132 @@
+# Vendored copy of cedar
+
+This directory holds a vendored copy of `cedar`, the double-array trie
+implementation that pycedar wraps.
+
+* Upstream: <http://www.tkl.iis.u-tokyo.ac.jp/~ynaga/cedar/>
+* Author: Naoki Yoshinaga
+* License: GPLv2, LGPLv2.1 and BSD-2-Clause (see `BSD`, `COPYING`, `GPL`, `LGPL`)
+
+This file records what was changed locally and why, so that a future maintainer
+who finds a newer tarball on the upstream site can decide what to do without
+repeating the investigation.
+(上流サイトに新しい tarball を見つけた人が、調査をやり直さずに判断できるようにするための記録)
+
+## What is actually used
+
+Only **one** file is compiled and shipped. Everything else is here because the
+original tarball was vendored wholesale, and is dead weight.
+
+| Path | Status |
+| --- | --- |
+| `src/cedarpp.h` | **Compiled and shipped.** The only file `pycedar.pxd` declares (`cdef extern from "cedarpp.h"`) and the only source `setup.py` ships in `package_data`. |
+| `AUTHORS`, `BSD`, `COPYING`, `GPL`, `LGPL`, `THANKS` | Shipped, for license compliance. |
+| `src/cedar.h`, `src/cedar.cc`, `src/bench.cc`, `src/bench_static.cc`, `src/mkcedar.cc`, `src/Makefile.am`, `Makefile.in` | Present in git, **never compiled and never shipped.** They differ substantially from upstream, which is irrelevant. |
+
+## Local modifications to `src/cedarpp.h`
+
+Upstream's error handler terminates the process:
+
+```cpp
+static void _err (const char* fn, const int ln, const char* msg)
+{ std::fprintf (stderr, "cedar: %s [%d]: %s", fn, ln, msg); std::exit (1); }
+```
+
+For a library loaded into a Python process that is unacceptable, so **four** of
+the five `_err()` call sites were converted to throw instead. The Cython
+declarations in `pycedar.pxd` carry `except +`, which turns the exception into a
+Python one.
+
+| Change | Reason |
+| --- | --- |
+| `#include <new>`, `#include <stdexcept>` | Needed by the `throw` sites below. |
+| `update()`: inserting a zero-length key throws `std::runtime_error` instead of calling `_err()` | Surfaces as a Python exception. `pycedar` rejects empty keys with `KeyError` before reaching this, so it is a backstop. |
+| `_realloc_array()`: a failed `realloc` throws `std::bad_alloc` instead of calling `_err()` | Surfaces as `MemoryError` rather than killing the interpreter. |
+| `shrink_tail()`: a failed `malloc` throws `std::bad_alloc` instead of calling `_err()` | Reached through `save()`, whose `shrink` argument defaults to `True`. Nothing has been mutated at that point, so the trie survives intact. |
+| `open()`: a failed `malloc` calls `fclose()`, then `clear(true)`, then throws `std::bad_alloc` | Reached through `load()`. Unlike the site above, `clear(false)` has already dropped the previous contents, so the object has to be reset to a valid empty trie before the exception escapes. |
+| `open()`: every early `return -1` closes the file first | Upstream leaks the `FILE*` on all nine of those paths. A loop of failed loads exhausts the descriptor table: 200 failed loads leaked exactly 200 descriptors before the fix. |
+| `_consult()` synced with upstream revision 1916 (2017-07-12) | Upstream bug fix, applied in [#2](https://github.com/akivajp/pycedar/pull/2). |
+| `clear()` layout and the `STATIC_ASSERT` pragmas taken from upstream | Pure formatting, adopted to remove the compiler warnings this copy used to emit. Reduces the delta against upstream rather than adding to it. |
+
+The original lines are kept as comments next to the replacements, so the delta
+against upstream stays readable.
+
+### The one `_err()` call site that is left
+
+`dump()` still calls `_err()`, and therefore still calls `std::exit(1)`. That is
+acceptable because `pycedar.pxd` does not declare `dump()`, so it is
+unreachable from Python. Check with:
+
+```shell
+$ grep -n '_err (__FILE__' pycedar/core/cedar/src/cedarpp.h
+```
+
+Every line that comes back should either be commented out or sit inside
+`dump()`. Anything else is a path that can kill the interpreter.
+(上記以外が出てきたら、インタプリタを落としうる経路が増えたということ)
+
+### What an allocation failure looks like from Python
+
+Every allocation failure raises `MemoryError`, because Cython's `except +` maps
+`std::bad_alloc` to it. Use `std::bad_alloc` — not `std::runtime_error` — for any
+further allocation site, so that all of them stay on one exception type.
+(確保失敗はすべて `MemoryError`。新たに確保箇所を足すときも `std::bad_alloc` を使うこと)
+
+`std::runtime_error` is reserved for the one non-allocation case, the
+zero-length key in `update()`, which reaches Python as `RuntimeError`.
+
+`load()` is destructive: recovering from a failed load leaves an **empty** trie,
+not the previous contents. cedar frees the old arrays before allocating the new
+ones, so the old contents are already gone by the time the failure is detected.
+(読み込み失敗後のトライは空になる。cedar は新規確保より前に旧配列を解放するため)
+
+## Upstream status, checked 2026-09-16
+
+The download page offers `cedar-latest.tar.gz`, which unpacks to
+`cedar-2022-03-18/`. That date is misleading:
+
+```
+cedar-2022-03-18/src/cedarpp.h
+  $Id: cedarpp.h 1916 2017-07-12 07:30:56Z ynaga $
+```
+
+**`cedarpp.h` itself has not changed upstream since 2017-07-12.** The 2022
+tarball is a repackage. The single functional change made in 2017 was the
+`_consult()` fix, and pycedar already carries it.
+
+Reproduce the comparison with:
+
+```shell
+$ curl -O http://www.tkl.iis.u-tokyo.ac.jp/~ynaga/cedar/cedar-latest.tar.gz
+$ tar xzf cedar-latest.tar.gz
+$ diff -u pycedar/core/cedar/src/cedarpp.h cedar-*/src/cedarpp.h
+```
+
+## Decision: the 2022 tarball was not re-vendored
+
+Once the `_consult()` fix landed, the remaining delta against upstream is only
+the deliberate local patches listed above, plus comment wording. Everything
+else that upstream had and this copy did not — the `clear()` layout and the
+`STATIC_ASSERT` pragmas — has since been adopted, which silenced the six
+compiler warnings this copy used to emit:
+
+```
+5 x -Wmisleading-indentation   (from the old clear() formatting)
+1 x -Wunused-local-typedefs    (from STATIC_ASSERT)
+```
+
+There is **no functional difference left to gain**. Re-vendoring wholesale would
+mean re-applying the patches by hand, and silently losing them would convert
+recoverable errors back into `std::exit(1)` and reintroduce the descriptor leak
+— the worst possible regressions for a library. That risk buys nothing.
+
+## If you do re-vendor
+
+1. Diff the new `src/cedarpp.h` against this copy first, and confirm that the
+   upstream `$Id:` revision actually changed. If it did not, stop.
+2. Re-apply every row of the modification table above.
+3. Verify that no reachable `_err()` call site came back:
+   `grep -n '_err (__FILE__' pycedar/core/cedar/src/cedarpp.h`
+4. Update the note at the top of `cedarpp.h` and this file.
+5. Run `pytest`. The suite includes randomized insert/delete consistency checks
+   that exercise the double-array rebalancing paths where upstream bugs live.

{pycedar-0.2.0 → pycedar-0.2.2}/pycedar/core/cedar/src/cedarpp.h

@@ -2,13 +2,19 @@
 //  $Id: cedarpp.h 1830 2014-06-16 06:17:42Z ynaga $
 // Copyright (c) 2009-2014 Naoki Yoshinaga <ynaga@tkl.iis.u-tokyo.ac.jp>
 //
-// NOTE (pycedar): this is a vendored copy of the upstream header with two
-// local modifications:
-//   1. _err() calls are replaced with `throw std::runtime_error` so that
-//      failures can be surfaced as Python exceptions (hence <stdexcept>).
-//   2. _consult() is synced with cedar-2022-03-18
-//      ($Id: cedarpp.h 1916 2017-07-12 07:30:56Z ynaga $).
-// Apart from these, this file is functionally identical to cedar-2022-03-18.
+// NOTE (pycedar): this is a vendored copy carrying local modifications. Four of
+// the five _err() call sites throw instead of calling std::exit(1) -- allocation
+// failures throw std::bad_alloc, which reaches Python as MemoryError -- and the
+// fifth is in dump(), which pycedar never reaches. open() also closes the file
+// on its early returns, which upstream does not. _consult(), the clear() layout
+// and the STATIC_ASSERT pragmas are synced with upstream revision 1916
+// (2017-07-12). Apart from that, this file is functionally identical to
+// cedar-2022-03-18 -- whose cedarpp.h is itself unchanged since 2017, so there
+// is nothing newer to pick up.
+//
+// Before editing or re-vendoring this file, read ../../README.md in this
+// repository (pycedar/core/cedar/README.md). It records what was changed, why,
+// and what must be re-applied if you ever sync with a newer upstream release.
 #ifndef CEDAR_H
 #define CEDAR_H
 
@@ -17,6 +23,7 @@
 #include <cstring>
 #include <climits>
 #include <cassert>
+#include <new>       // std::bad_alloc
 #include <stdexcept> // std::runtime_error
 
 #ifdef HAVE_CONFIG_H
@@ -79,9 +86,11 @@ namespace cedar {
       block () : prev (0), next (0), num (256), reject (257), trial (0), ehead (0) {}
     };
     da () : tracking_node (), _array (0), _tail (0), _tail0 (0), _ninfo (0), _block (0), _bheadF (0), _bheadC (0), _bheadO (0), _capacity (0), _size (0), _quota (0), _quota0 (0), _no_delete (false), _reject () {
+#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
       STATIC_ASSERT(sizeof (value_type) <= sizeof (int),
                     value_type_is_not_supported___maintain_a_value_array_by_yourself_and_store_its_index_to_trie
                     );
+#pragma GCC diagnostic warning "-Wunused-local-typedefs"
       _initialize ();
     }
     ~da () { clear (false); }
@@ -331,7 +340,10 @@ namespace cedar {
         = static_cast <size_t> (*_length)
         - static_cast <size_t> (*_length0) * (1 + sizeof (value_type));
       t.tail = static_cast <char*> (std::malloc (length_));
-      if (! t.tail) _err (__FILE__, __LINE__, "memory allocation failed\n");
+      if (! t.tail)
+        // pycedar: nothing has been mutated yet, so the trie survives intact.
+        //_err (__FILE__, __LINE__, "memory allocation failed\n");
+        throw std::bad_alloc ();
       *t.length = static_cast <int> (sizeof (int));
       for (int to = 0; to < _size; ++to) {
         node& n = _array[to];
@@ -383,16 +395,16 @@ namespace cedar {
       if (! fp) return -1;
       // get size
       if (! size_) {
-        if (std::fseek (fp, 0, SEEK_END) != 0) return -1;
+        if (std::fseek (fp, 0, SEEK_END) != 0) { std::fclose (fp); return -1; }
         size_ = static_cast <size_t> (std::ftell (fp));
-        if (std::fseek (fp, 0, SEEK_SET) != 0) return -1;
+        if (std::fseek (fp, 0, SEEK_SET) != 0) { std::fclose (fp); return -1; }
       }
-      if (size_ <= offset) return -1;
-      if (std::fseek (fp, static_cast <long> (offset), SEEK_SET) != 0) return -1;
+      if (size_ <= offset) { std::fclose (fp); return -1; }
+      if (std::fseek (fp, static_cast <long> (offset), SEEK_SET) != 0) { std::fclose (fp); return -1; }
       int len = 0;
-      if (std::fread (&len, sizeof (int), 1, fp) != 1) return -1;
+      if (std::fread (&len, sizeof (int), 1, fp) != 1) { std::fclose (fp); return -1; }
       const size_t length_ = static_cast <size_t> (len);
-      if (size_ <= offset + length_) return -1;
+      if (size_ <= offset + length_) { std::fclose (fp); return -1; }
       // set array
       clear (false);
       size_ = (size_ - offset - length_) / sizeof (node);
@@ -406,11 +418,18 @@ namespace cedar {
 #else
       if (! _array || ! _tail || ! _tail0)
 #endif
-        _err (__FILE__, __LINE__, "memory allocation failed\n");
-      if (std::fseek (fp, static_cast <long> (offset), SEEK_SET) != 0) return -1;
+        //_err (__FILE__, __LINE__, "memory allocation failed\n");
+        { // pycedar: clear (false) above already dropped the previous contents,
+          // so reset to a valid empty trie before reporting the failure;
+          // otherwise the caller would be handed a half-built object.
+          std::fclose (fp);
+          clear (true);
+          throw std::bad_alloc ();
+        }
+      if (std::fseek (fp, static_cast <long> (offset), SEEK_SET) != 0) { std::fclose (fp); return -1; }
       if (length_ != std::fread (_tail,  sizeof (char), length_, fp) ||
           size_   != std::fread (_array, sizeof (node), size_,   fp))
-        return -1;
+        { std::fclose (fp); return -1; }
       std::fclose (fp);
       _size = static_cast <int> (size_);
       *_length0 = 0;
@@ -425,7 +444,7 @@ namespace cedar {
       std::fread (&_bheadO, sizeof (int), 1, fp);
       if (size_      != std::fread (_ninfo, sizeof (ninfo), size_, fp) ||
           size_ >> 8 != std::fread (_block, sizeof (block), size_ >> 8, fp))
-        return -1;
+        { std::fclose (fp); return -1; }
       std::fclose (fp);
       _capacity = _size;
       _quota  = *_length;
@@ -454,11 +473,12 @@ namespace cedar {
     const void* array () const { return _array; }
     void clear (const bool reuse = true) {
       if (_no_delete) _array = 0, _tail = 0;
-      if (_array) std::free (_array); _array = 0;
-      if (_tail)  std::free (_tail);  _tail  = 0;
-      if (_tail0) std::free (_tail0); _tail0 = 0;
-      if (_ninfo) std::free (_ninfo); _ninfo = 0;
-      if (_block) std::free (_block); _block = 0;
+      if (_array) std::free (_array);
+      if (_tail)  std::free (_tail);
+      if (_tail0) std::free (_tail0);
+      if (_ninfo) std::free (_ninfo);
+      if (_block) std::free (_block);
+      _array = 0; _tail = 0; _tail0 = 0; _ninfo = 0; _block = 0;
       _bheadF = _bheadC = _bheadO = _capacity = _size = _quota = _quota0 = 0;
       if (reuse) _initialize ();
       _no_delete = false;
@@ -529,7 +549,7 @@ namespace cedar {
       void* tmp = std::realloc (p, sizeof (T) * static_cast <size_t> (size_n));
       if (! tmp)
         //std::free (p), _err (__FILE__, __LINE__, "memory reallocation failed\n");
-        throw std::runtime_error("memory reallocation failed");
+        throw std::bad_alloc ();
       p = static_cast <T*> (tmp);
       static const T T0 = T ();
       for (T* q (p + size_p), * const r (p + size_n); q != r; ++q) *q = T0;