middlemac 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 577f3591f5f815b959d9a272ea275cbaa18b19996c4234312fcb177aa3b56df0
-  data.tar.gz: 4c6765e7f1d9a70043301616d7245deb167c1e87de787b8cd3e830298a112efe
+  metadata.gz: 9cc65eec33bce51ed9f9895d28f87491bf7f3ec0165928e4ac61e82f7fb0994f
+  data.tar.gz: a092b0da52ba6da22fb0487984488a6fb4b16648a3db8ae61913d0d98e959a8b
 SHA512:
-  metadata.gz: 780edeb0005d4a5ce14210306b63b297518ba471c0904510260722de7155f1e0ec54141ab3cc310c1592b3da217377efec6bd71f5e9aa2610bf115769d7e2076
-  data.tar.gz: 8d1856e6b75850ca86e7bab12cb702e93f5af2536384798e1a5d656800c46813b5efee6c1d53f2506ba9c93da380ec6a36870eae389b64fd9c5975f9cbc8a741
+  metadata.gz: 4640aba23a4ae0e588ea1f75805e211fd6c9060767baea5864158951ddc900b1b21377b5369397a55e7e379c0803afe1ae7d96792b0cf2061c466b0aa44c6b62
+  data.tar.gz: eb53d93c3ea28dc7894efae7191bc0d104b2ca8cb7a06251338fd25869efe799c9c6d5c5eb1a09e51cc572d8dd87fb1792cbf1addc5123b57f08862b34ce856a

data/.gitignore

@@ -22,3 +22,9 @@ build/*
 
 # Aruba
 /tmp/
+
+# Native Extension Build
+/lib/trie
+
+# Fixture build folder when testing.
+/fixtures/middlemac_app/New_Project_(pro).help

data/CHANGELOG.md

@@ -1,6 +1,23 @@
 middlemac change log
 ====================
 
+- Version 3.1.1 / 2021-April-12
+
+  - Compatibility Updates
+      - Version bump.
+      - Vendor the source of the fast_trie gem, because it's no longer maintained, and I
+        don't want to create another unmaintained Ruby gem. Updates to fast_trie are needed
+        because Clang now has added diagnostics including default C99 which causes the
+        original fast_trie to no longer build. I've also silenced warnings.
+      - Make the landing page use target magic images instead of the static image it uses.
+        This means you should have `target1-icon_256x256` and `target2-icon_256x256` in
+        your images, or to use the same icon for all targets, `all-icon_256x256`.
+      - Enforce a newer minimum Middleman version, because it has removed support for
+        automatic alt attributes, and we've done the same. This keeps us in sync.
+      - Enforce Ruby versions. Right now Ruby 2.6.0 approaching 3.0 is supported. Once
+        Middleman has a numbered release supporting Ruby 3.0, I'll take a look at supporting
+        it.
+
 - Version 3.1.0 / 2019-October-11
 
   - Version 3.1.0
@@ -58,4 +75,3 @@ middlemac change log
   - README, getting started.
   - Overhaul of helpers and sitemap manipulators complete.
   - BRETHREN checkpoint
-  - Continued refactoring resources.

data/Rakefile

@@ -1,3 +1,4 @@
+require "rake/extensiontask"
 require 'bundler/gem_tasks'
 require 'cucumber/rake/task'
 require 'yard'
@@ -5,23 +6,33 @@ require 'git'
 require File.expand_path('../lib/middlemac/version.rb', __FILE__)
 
 
+###############################################################################
+# ExtensionTask.new
+#   Compile the native extensions.
+###############################################################################
+Rake::ExtensionTask.new("trie") do |ext|
+  ext.ext_dir = 'ext/trie'
+  ext.lib_dir = 'lib/trie'
+end
+
+
 ###############################################################################
 # :default
 #   Define the default task.
 ###############################################################################
-task :default => :test
+task :default => [:compile, :test]
 
 
 ###############################################################################
 # :test
 #   Perform Cucumber testing.
 ###############################################################################
-Cucumber::Rake::Task.new(:test, 'Features that must pass') do |task|
-  task.cucumber_opts = '--require features --color --tags "not @wip" --strict --format pretty'
+Cucumber::Rake::Task.new(:test, 'Features that must pass; do "rake compile" first!') do |task|
+  task.cucumber_opts = '--publish-quiet --require features --color --tags "not @wip" --strict --format pretty 2>/dev/null'
 end
 
-Cucumber::Rake::Task.new(:testq, 'Features that must pass') do |task|
-  task.cucumber_opts = '--require features --color --tags "not @wip" --strict --format pretty 2>/dev/null'
+Cucumber::Rake::Task.new(:testnoisy, 'Features that must pass; do "rake compile" first!') do |task|
+  task.cucumber_opts = '--publish-quiet --require features --color --tags "not @wip" --strict --format pretty'
 end
 
 

data/documentation_project/Contents/Resources/SharedGlobalAssets/_layouts/layout-apple-modern.haml

@@ -20,12 +20,12 @@
     %a{:name => current_page.data.anchor || current_page.page_name}
 
     - if landing
-      = image_tag "icon_256x256"
+      = image_tag "all-icon_256x256"
       %h1 #{product_name} #{product_version}
       %h2
         %a{:href => "#{product_uri}" } #{product_uri}
     - else
-      = image_tag current_page.data.topicIcon || "icon_256x256", :figure_class => 'topicIcon'
+      = image_tag current_page.data.topicIcon || "all-icon_256x256", :figure_class => 'topicIcon'
       %h1 #{current_page.data.title}
     
     = yield

data/documentation_project/Gemfile

@@ -17,14 +17,14 @@ source 'https://rubygems.org'
 #######################################
 # Middlemac, natch.
 #######################################
-gem 'middlemac', '~> 3.1.0'
+gem 'middlemac', '~> 3.1.1'
 gem 'middleman-targets', '~> 1.0.12'
 
 
 #######################################
 # Core gems
 #######################################
-gem 'middleman', '~> 4.2.0'
+gem 'middleman', '~> 4.3.7'
 gem 'middleman-core'
 gem 'middleman-cli'
 gem 'middleman-livereload' # Live-reloading plugin

data/documentation_project/config.rb

@@ -94,9 +94,9 @@ config[:targets] = {
                 :HPDBookIconPath  => 'SharedGlobalArt/free-icon_32x32@2x.png',
                 :CFBundleName     => 'Middlemac',
                 :ProductName      => 'Middlemac',
-                :ProductVersion   => version_app || '3.1.0',
+                :ProductVersion   => version_app || '3.1.1',
                 :ProductURI       => 'http://www.balthisar.com/developer',
-                :ProductCopyright => '© 2019 Jim Derry. All rights reserved.',
+                :ProductCopyright => '© 2021 Jim Derry. All rights reserved.',
                 :features =>
                     {
                         :feature_advertise_pro        => true,
@@ -112,9 +112,9 @@ config[:targets] = {
                 :HPDBookIconPath  => 'SharedGlobalArt/pro-icon_32x32@2x.png',
                 :CFBundleName     => 'Middlemac',
                 :ProductName      => 'Middlemac Pro',
-                :ProductVersion   => version_app || '3.1.0',
+                :ProductVersion   => version_app || '3.1.1',
                 :ProductURI       => 'http://www.balthisar.com/developer',
-                :ProductCopyright => '© 2019 Jim Derry. All rights reserved.',
+                :ProductCopyright => '© 2021 Jim Derry. All rights reserved.',
                 :features =>
                     {
                         :feature_advertise_pro        => false,
@@ -227,11 +227,12 @@ set :strip_index_file, false
 
 #===============================================================
 # Default to HTML5 Layout.
+# Specify layouts from most specific to least specific.
 #===============================================================
 Haml::TempleEngine.disable_option_validator!
 set :haml, :format => :html5
-page 'Resources/*.lproj/*.html', :layout => :'layout-apple-modern'
 page 'Resources/*.lproj/asides/*.html', :layout => :'layout-apple-modern-aside'
+page 'Resources/*.lproj/*.html', :layout => :'layout-apple-modern'
 
 
 #===============================================================

data/ext/trie/darray.c

@@ -0,0 +1,673 @@
+/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * darray.c - Double-array trie structure
+ * Created: 2006-08-13
+ * Author:  Theppitak Karoonboonyanan <thep@linux.thai.net>
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "trie-private.h"
+#include "darray.h"
+#include "fileutils.h"
+
+/*----------------------------------*
+ *    INTERNAL TYPES DECLARATIONS   *
+ *----------------------------------*/
+
+typedef struct _Symbols Symbols;
+
+struct _Symbols {
+    short       num_symbols;
+    TrieChar    symbols[256];
+};
+
+static Symbols *    symbols_new ();
+static void         symbols_free (Symbols *syms);
+static void         symbols_add (Symbols *syms, TrieChar c);
+
+#define symbols_num(s)          ((s)->num_symbols)
+#define symbols_get(s,i)        ((s)->symbols[i])
+#define symbols_add_fast(s,c)   ((s)->symbols[(s)->num_symbols++] = c)
+
+/*-----------------------------------*
+ *    PRIVATE METHODS DECLARATIONS   *
+ *-----------------------------------*/
+
+#define da_get_free_list(d)      (1)
+
+static Bool         da_check_free_cell (DArray         *d,
+                                        TrieIndex       s);
+
+static Bool         da_has_children    (DArray         *d,
+                                        TrieIndex       s);
+
+static Symbols *    da_output_symbols  (const DArray   *d,
+                                        TrieIndex       s);
+
+static TrieChar *   da_get_state_key   (const DArray   *d,
+                                        TrieIndex       state);
+
+static TrieIndex    da_find_free_base  (DArray         *d,
+                                        const Symbols  *symbols);
+
+static Bool         da_fit_symbols     (DArray         *d,
+                                        TrieIndex       base,
+                                        const Symbols  *symbols);
+
+static void         da_relocate_base   (DArray         *d,
+                                        TrieIndex       s,
+                                        TrieIndex       new_base);
+
+static Bool         da_extend_pool     (DArray         *d,
+                                        TrieIndex       to_index);
+
+static void         da_alloc_cell      (DArray         *d,
+                                        TrieIndex       cell);
+
+static void         da_free_cell       (DArray         *d,
+                                        TrieIndex       cell);
+
+static Bool         da_enumerate_recursive (const DArray   *d,
+                                            TrieIndex       state,
+                                            DAEnumFunc      enum_func,
+                                            void           *user_data);
+
+/* ==================== BEGIN IMPLEMENTATION PART ====================  */
+
+/*------------------------------------*
+ *   INTERNAL TYPES IMPLEMENTATIONS   *
+ *------------------------------------*/
+
+static Symbols *
+symbols_new ()
+{
+    Symbols *syms;
+
+    syms = (Symbols *) malloc (sizeof (Symbols));
+
+    if (!syms)
+        return NULL;
+
+    syms->num_symbols = 0;
+
+    return syms;
+}
+
+static void
+symbols_free (Symbols *syms)
+{
+    free (syms);
+}
+
+static void
+symbols_add (Symbols *syms, TrieChar c)
+{
+    short lower, upper;
+
+    lower = 0;
+    upper = syms->num_symbols;
+    while (lower < upper) {
+        short middle;
+
+        middle = (lower + upper)/2;
+        if (c > syms->symbols[middle])
+            lower = middle + 1;
+        else if (c < syms->symbols[middle])
+            upper = middle;
+        else
+            return;
+    }
+    if (lower < syms->num_symbols) {
+        memmove (syms->symbols + lower + 1, syms->symbols + lower,
+                 syms->num_symbols - lower);
+    }
+    syms->symbols[lower] = c;
+    syms->num_symbols++;
+}
+
+/*------------------------------*
+ *    PRIVATE DATA DEFINITONS   *
+ *------------------------------*/
+
+typedef struct {
+    TrieIndex   base;
+    TrieIndex   check;
+} DACell;
+
+struct _DArray {
+    TrieIndex   num_cells;
+    DACell     *cells;
+};
+
+/*-----------------------------*
+ *    METHODS IMPLEMENTAIONS   *
+ *-----------------------------*/
+
+#define DA_SIGNATURE 0xDAFCDAFC
+
+/* DA Header:
+ * - Cell 0: SIGNATURE, number of cells
+ * - Cell 1: free circular-list pointers
+ * - Cell 2: root node
+ * - Cell 3: DA pool begin
+ */
+#define DA_POOL_BEGIN 3
+
+DArray *
+da_new ()
+{
+    DArray     *d;
+
+    d = (DArray *) malloc (sizeof (DArray));
+    if (!d)
+        return NULL;
+
+    d->num_cells = DA_POOL_BEGIN;
+    d->cells     = (DACell *) malloc (d->num_cells * sizeof (DACell));
+    if (!d->cells)
+        goto exit_da_created;
+    d->cells[0].base = DA_SIGNATURE;
+    d->cells[0].check = d->num_cells;
+    d->cells[1].base = -1;
+    d->cells[1].check = -1;
+    d->cells[2].base = DA_POOL_BEGIN;
+    d->cells[2].check = 0;
+
+    return d;
+
+exit_da_created:
+    free (d);
+    return NULL;
+}
+
+DArray *
+da_read (FILE *file)
+{
+    long        save_pos;
+    DArray     *d = NULL;
+    TrieIndex   n;
+
+    /* check signature */
+    save_pos = ftell (file);
+    if (!file_read_int32 (file, &n) || DA_SIGNATURE != (uint32) n) {
+        fseek (file, save_pos, SEEK_SET);
+        return NULL;
+    }
+
+    d = (DArray *) malloc (sizeof (DArray));
+    if (!d)
+        return NULL;
+
+    /* read number of cells */
+    file_read_int32 (file, &d->num_cells);
+    d->cells     = (DACell *) malloc (d->num_cells * sizeof (DACell));
+    if (!d->cells)
+        goto exit_da_created;
+    d->cells[0].base = DA_SIGNATURE;
+    d->cells[0].check= d->num_cells;
+    for (n = 1; n < d->num_cells; n++) {
+        file_read_int32 (file, &d->cells[n].base);
+        file_read_int32 (file, &d->cells[n].check);
+    }
+
+    return d;
+
+exit_da_created:
+    free (d);
+    return NULL;
+}
+
+void
+da_free (DArray *d)
+{
+    free (d->cells);
+    free (d);
+}
+
+int
+da_write (const DArray *d, FILE *file)
+{
+    TrieIndex   i;
+
+    for (i = 0; i < d->num_cells; i++) {
+        if (!file_write_int32 (file, d->cells[i].base) ||
+            !file_write_int32 (file, d->cells[i].check))
+        {
+            return -1;
+        }
+    }
+
+    return 0;
+}
+
+
+TrieIndex
+da_get_root (const DArray *d)
+{
+    /* can be calculated value for multi-index trie */
+    return 2;
+}
+
+
+TrieIndex
+da_get_base (const DArray *d, TrieIndex s)
+{
+    return (0 <= s && s < d->num_cells) ? d->cells[s].base : TRIE_INDEX_ERROR;
+}
+
+TrieIndex
+da_get_check (const DArray *d, TrieIndex s)
+{
+    return (0 <= s && s < d->num_cells) ? d->cells[s].check : TRIE_INDEX_ERROR;
+}
+
+
+void
+da_set_base (DArray *d, TrieIndex s, TrieIndex val)
+{
+    if (0 <= s && s < d->num_cells) {
+        d->cells[s].base = val;
+    }
+}
+
+void
+da_set_check (DArray *d, TrieIndex s, TrieIndex val)
+{
+    if (0 <= s && s < d->num_cells) {
+        d->cells[s].check = val;
+    }
+}
+
+Bool
+da_walk (const DArray *d, TrieIndex *s, TrieChar c)
+{
+    TrieIndex   next;
+
+    next = da_get_base (d, *s) + c;
+    if (da_get_check (d, next) == *s) {
+        *s = next;
+        return TRUE;
+    }
+    return FALSE;
+}
+
+TrieIndex
+da_insert_branch (DArray *d, TrieIndex s, TrieChar c)
+{
+    TrieIndex   base, next;
+
+    base = da_get_base (d, s);
+
+    if (base > 0) {
+        next = base + c;
+
+        /* if already there, do not actually insert */
+        if (da_get_check (d, next) == s)
+            return next;
+
+        /* if (base + c) > TRIE_INDEX_MAX which means 'next' is overflow,
+         * or cell [next] is not free, relocate to a free slot
+         */
+        if (base > TRIE_INDEX_MAX - c || !da_check_free_cell (d, next)) {
+            Symbols    *symbols;
+            TrieIndex   new_base;
+
+            /* relocate BASE[s] */
+            symbols = da_output_symbols (d, s);
+            symbols_add (symbols, c);
+            new_base = da_find_free_base (d, symbols);
+            symbols_free (symbols);
+
+            if (TRIE_INDEX_ERROR == new_base)
+                return TRIE_INDEX_ERROR;
+
+            da_relocate_base (d, s, new_base);
+            next = new_base + c;
+        }
+    } else {
+        Symbols    *symbols;
+        TrieIndex   new_base;
+
+        symbols = symbols_new ();
+        symbols_add (symbols, c);
+        new_base = da_find_free_base (d, symbols);
+        symbols_free (symbols);
+
+        if (TRIE_INDEX_ERROR == new_base)
+            return TRIE_INDEX_ERROR;
+
+        da_set_base (d, s, new_base);
+        next = new_base + c;
+    }
+    da_alloc_cell (d, next);
+    da_set_check (d, next, s);
+
+    return next;
+}
+
+static Bool
+da_check_free_cell (DArray         *d,
+                    TrieIndex       s)
+{
+    return da_extend_pool (d, s) && da_get_check (d, s) < 0;
+}
+
+static Bool
+da_has_children    (DArray         *d,
+                    TrieIndex       s)
+{
+    TrieIndex   base;
+    TrieIndex   c, max_c;
+
+    base = da_get_base (d, s);
+    if (TRIE_INDEX_ERROR == base || base < 0)
+        return FALSE;
+
+    max_c = MIN_VAL (TRIE_CHAR_MAX, TRIE_INDEX_MAX - base);
+    for (c = 0; c < max_c; c++) {
+        if (da_get_check (d, base + c) == s)
+            return TRUE;
+    }
+
+    return FALSE;
+}
+
+static Symbols *
+da_output_symbols  (const DArray   *d,
+                    TrieIndex       s)
+{
+    Symbols    *syms;
+    TrieIndex   base;
+    TrieIndex   c, max_c;
+
+    syms = symbols_new ();
+
+    base = da_get_base (d, s);
+    max_c = MIN_VAL (TRIE_CHAR_MAX, TRIE_INDEX_MAX - base);
+    for (c = 0; c < max_c; c++) {
+        if (da_get_check (d, base + c) == s)
+            symbols_add_fast (syms, (TrieChar) c);
+    }
+
+    return syms;
+}
+
+static TrieChar *
+da_get_state_key   (const DArray   *d,
+                    TrieIndex       state)
+{
+    TrieChar   *key;
+    int         key_size, key_length;
+    int         i;
+
+    key_size = 20;
+    key_length = 0;
+    key = (TrieChar *) malloc (key_size);
+
+    /* trace back to root */
+    while (da_get_root (d) != state) {
+        TrieIndex   parent;
+
+        if (key_length + 1 >= key_size) {
+            key_size += 20;
+            key = (TrieChar *) realloc (key, key_size);
+        }
+        parent = da_get_check (d, state);
+        key[key_length++] = (TrieChar) (state - da_get_base (d, parent));
+        state = parent;
+    }
+    key[key_length] = '\0';
+
+    /* reverse the string */
+    for (i = 0; i < --key_length; i++) {
+        TrieChar temp;
+
+        temp = key[i];
+        key[i] = key[key_length];
+        key[key_length] = temp;
+    }
+
+    return key;
+}
+
+static TrieIndex
+da_find_free_base  (DArray         *d,
+                    const Symbols  *symbols)
+{
+    TrieChar        first_sym;
+    TrieIndex       s;
+
+    /* find first free cell that is beyond the first symbol */
+    first_sym = symbols_get (symbols, 0);
+    s = -da_get_check (d, da_get_free_list (d));
+    while (s != da_get_free_list (d)
+           && s < (TrieIndex) first_sym + DA_POOL_BEGIN)
+    {
+        s = -da_get_check (d, s);
+    }
+    if (s == da_get_free_list (d)) {
+        for (s = first_sym + DA_POOL_BEGIN; ; ++s) {
+            if (!da_extend_pool (d, s))
+                return TRIE_INDEX_ERROR;
+            if (da_get_check (d, s) < 0)
+                break;
+        }
+    }
+
+    /* search for next free cell that fits the symbols set */
+    while (!da_fit_symbols (d, s - first_sym, symbols)) {
+        /* extend pool before getting exhausted */
+        if (-da_get_check (d, s) == da_get_free_list (d)) {
+            if (!da_extend_pool (d, d->num_cells))
+                return TRIE_INDEX_ERROR;
+        }
+
+        s = -da_get_check (d, s);
+    }
+
+    return s - first_sym;
+}
+
+static Bool
+da_fit_symbols     (DArray         *d,
+                    TrieIndex       base,
+                    const Symbols  *symbols)
+{
+    int         i;
+
+    for (i = 0; i < symbols_num (symbols); i++) {
+        TrieChar    sym = symbols_get (symbols, i);
+
+        /* if (base + sym) > TRIE_INDEX_MAX which means it's overflow,
+         * or cell [base + sym] is not free, the symbol is not fit.
+         */
+        if (base > TRIE_INDEX_MAX - sym || !da_check_free_cell (d, base + sym))
+            return FALSE;
+    }
+    return TRUE;
+}
+
+static void
+da_relocate_base   (DArray         *d,
+                    TrieIndex       s,
+                    TrieIndex       new_base)
+{
+    TrieIndex   old_base;
+    Symbols    *symbols;
+    int         i;
+
+    old_base = da_get_base (d, s);
+    symbols = da_output_symbols (d, s);
+
+    for (i = 0; i < symbols_num (symbols); i++) {
+        TrieIndex   old_next, new_next, old_next_base;
+
+        old_next = old_base + symbols_get (symbols, i);
+        new_next = new_base + symbols_get (symbols, i);
+        old_next_base = da_get_base (d, old_next);
+
+        /* allocate new next node and copy BASE value */
+        da_alloc_cell (d, new_next);
+        da_set_check (d, new_next, s);
+        da_set_base (d, new_next, old_next_base);
+
+        /* old_next node is now moved to new_next
+         * so, all cells belonging to old_next
+         * must be given to new_next
+         */
+        /* preventing the case of TAIL pointer */
+        if (old_next_base > 0) {
+            TrieIndex   c, max_c;
+
+            max_c = MIN_VAL (TRIE_CHAR_MAX, TRIE_INDEX_MAX - old_next_base);
+            for  (c = 0; c < max_c; c++) {
+                if (da_get_check (d, old_next_base + c) == old_next)
+                    da_set_check (d, old_next_base + c, new_next);
+            }
+        }
+
+        /* free old_next node */
+        da_free_cell (d, old_next);
+    }
+
+    symbols_free (symbols);
+
+    /* finally, make BASE[s] point to new_base */
+    da_set_base (d, s, new_base);
+}
+
+static Bool
+da_extend_pool     (DArray         *d,
+                    TrieIndex       to_index)
+{
+    TrieIndex   new_begin;
+    TrieIndex   i;
+    TrieIndex   free_tail;
+
+    if (to_index <= 0 || TRIE_INDEX_MAX <= to_index)
+        return FALSE;
+
+    if (to_index < d->num_cells)
+        return TRUE;
+
+    d->cells = (DACell *) realloc (d->cells, (to_index + 1) * sizeof (DACell));
+    new_begin = d->num_cells;
+    d->num_cells = to_index + 1;
+
+    /* initialize new free list */
+    for (i = new_begin; i < to_index; i++) {
+        da_set_check (d, i, -(i + 1));
+        da_set_base (d, i + 1, -i);
+    }
+
+    /* merge the new circular list to the old */
+    free_tail = -da_get_base (d, da_get_free_list (d));
+    da_set_check (d, free_tail, -new_begin);
+    da_set_base (d, new_begin, -free_tail);
+    da_set_check (d, to_index, -da_get_free_list (d));
+    da_set_base (d, da_get_free_list (d), -to_index);
+
+    /* update header cell */
+    d->cells[0].check = d->num_cells;
+
+    return TRUE;
+}
+
+void
+da_prune (DArray *d, TrieIndex s)
+{
+    da_prune_upto (d, da_get_root (d), s);
+}
+
+void
+da_prune_upto (DArray *d, TrieIndex p, TrieIndex s)
+{
+    while (p != s && !da_has_children (d, s)) {
+        TrieIndex   parent;
+
+        parent = da_get_check (d, s);
+        da_free_cell (d, s);
+        s = parent;
+    }
+}
+
+static void
+da_alloc_cell      (DArray         *d,
+                    TrieIndex       cell)
+{
+    TrieIndex   prev, next;
+
+    prev = -da_get_base (d, cell);
+    next = -da_get_check (d, cell);
+
+    /* remove the cell from free list */
+    da_set_check (d, prev, -next);
+    da_set_base (d, next, -prev);
+}
+
+static void
+da_free_cell       (DArray         *d,
+                    TrieIndex       cell)
+{
+    TrieIndex   i, prev;
+
+    /* find insertion point */
+    i = -da_get_check (d, da_get_free_list (d));
+    while (i != da_get_free_list (d) && i < cell)
+        i = -da_get_check (d, i);
+
+    prev = -da_get_base (d, i);
+
+    /* insert cell before i */
+    da_set_check (d, cell, -i);
+    da_set_base (d, cell, -prev);
+    da_set_check (d, prev, -cell);
+    da_set_base (d, i, -cell);
+}
+
+Bool
+da_enumerate (const DArray *d, DAEnumFunc enum_func, void *user_data)
+{
+    return da_enumerate_recursive (d, da_get_root (d), enum_func, user_data);
+}
+
+static Bool
+da_enumerate_recursive (const DArray   *d,
+                        TrieIndex       state,
+                        DAEnumFunc      enum_func,
+                        void           *user_data)
+{
+    Bool        ret;
+    TrieIndex   base;
+
+    base = da_get_base (d, state);
+
+    if (base < 0) {
+        TrieChar   *key;
+
+        key = da_get_state_key (d, state);
+        ret = (*enum_func) (key, state, user_data);
+        free (key);
+    } else {
+        Symbols *symbols;
+        int      i;
+
+        ret = TRUE;
+        symbols = da_output_symbols (d, state);
+        for (i = 0; ret && i < symbols_num (symbols); i++) {
+            ret = da_enumerate_recursive (d, base + symbols_get (symbols, i),
+                                          enum_func, user_data);
+        }
+
+        symbols_free (symbols);
+    }
+
+    return ret;
+}
+
+/*
+vi:ts=4:ai:expandtab
+*/