X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Foutput%2Ftable.c;h=3d07eb40d47563b27c059ee36d0473ce94d85c47;hb=dfb794fa53a423c1f20c3a21811c0bec4a64a916;hp=e354bb3edfc540a9b920a61e68a3e59fe773d411;hpb=70f8feea0e76d9aaae3656f886729b2c6ea3c2c1;p=pspp

diff --git a/src/output/table.c b/src/output/table.c
index e354bb3edf..3d07eb40d4 100644
--- a/src/output/table.c
+++ b/src/output/table.c
@@ -20,14 +20,25 @@
 #include "output/table-provider.h"
 
 #include <assert.h>
+#include <inttypes.h>
 #include <stdlib.h>
 
+#include "data/format.h"
+#include "libpspp/assertion.h"
 #include "libpspp/cast.h"
 #include "libpspp/compiler.h"
-#include "output/table-item.h"
+#include "libpspp/pool.h"
+#include "libpspp/str.h"
+#include "output/output-item.h"
+#include "output/pivot-table.h"
+#include "output/table.h"
 
 #include "gl/xalloc.h"
 
+/* This file uses TABLE_HORZ and TABLE_VERT enough to warrant abbreviating. */
+#define H TABLE_HORZ
+#define V TABLE_VERT
+
 /* Increases TABLE's reference count, indicating that it has an additional
    owner.  An table that is shared among multiple owners must not be
    modified. */
@@ -48,7 +59,7 @@ table_unref (struct table *table)
     {
       assert (table->ref_cnt > 0);
       if (--table->ref_cnt == 0)
-        table->klass->destroy (table);
+        pool_destroy (table->container);
     }
 }
 
@@ -59,100 +70,377 @@ table_is_shared (const struct table *table)
 {
   return table->ref_cnt > 1;
 }
+
+struct table_area_style *
+table_area_style_clone (struct pool *pool, const struct table_area_style *old)
+{
+  struct table_area_style *new = pool_malloc (pool, sizeof *new);
+  *new = *old;
+  if (new->font_style.typeface)
+    new->font_style.typeface = pool_strdup (pool, new->font_style.typeface);
+  return new;
+}
+
+void
+table_area_style_free (struct table_area_style *style)
+{
+  if (style)
+    {
+      free (style->font_style.typeface);
+      free (style);
+    }
+}
+
+const char *
+table_halign_to_string (enum table_halign halign)
+{
+  switch (halign)
+    {
+    case TABLE_HALIGN_LEFT: return "left";
+    case TABLE_HALIGN_CENTER: return "center";
+    case TABLE_HALIGN_RIGHT: return "right";
+    case TABLE_HALIGN_DECIMAL: return "decimal";
+    case TABLE_HALIGN_MIXED: return "mixed";
+    default: return "**error**";
+    }
+}
+
+const char *
+table_valign_to_string (enum table_valign valign)
+{
+  switch (valign)
+    {
+    case TABLE_VALIGN_TOP: return "top";
+    case TABLE_VALIGN_CENTER: return "center";
+    case TABLE_VALIGN_BOTTOM: return "bottom";
+    default: return "**error**";
+    }
+}
+
+enum table_halign
+table_halign_interpret (enum table_halign halign, bool numeric)
+{
+  switch (halign)
+    {
+    case TABLE_HALIGN_LEFT:
+    case TABLE_HALIGN_CENTER:
+    case TABLE_HALIGN_RIGHT:
+      return halign;
+
+    case TABLE_HALIGN_MIXED:
+      return numeric ? TABLE_HALIGN_RIGHT : TABLE_HALIGN_LEFT;
+
+    case TABLE_HALIGN_DECIMAL:
+      return TABLE_HALIGN_DECIMAL;
+
+    default:
+      NOT_REACHED ();
+    }
+}
 
-/* Sets the number of left header columns in TABLE to HL. */
 void
-table_set_hl (struct table *table, int hl)
+font_style_copy (struct pool *container,
+                 struct font_style *dst, const struct font_style *src)
 {
-  assert (!table_is_shared (table));
-  table->h[TABLE_HORZ][0] = hl;
+  *dst = *src;
+  if (dst->typeface)
+    dst->typeface = pool_strdup (container, dst->typeface);
 }
 
-/* Sets the number of right header columns in TABLE to HR. */
 void
-table_set_hr (struct table *table, int hr)
+font_style_uninit (struct font_style *font)
 {
-  assert (!table_is_shared (table));
-  table->h[TABLE_HORZ][1] = hr;
+  if (font)
+    free (font->typeface);
 }
 
-/* Sets the number of top header rows in TABLE to HT. */
 void
-table_set_ht (struct table *table, int ht)
+table_area_style_copy (struct pool *container, struct table_area_style *dst,
+                       const struct table_area_style *src)
 {
-  assert (!table_is_shared (table));
-  table->h[TABLE_VERT][0] = ht;
+  font_style_copy (container, &dst->font_style, &src->font_style);
+  dst->cell_style = src->cell_style;
 }
 
-/* Sets the number of top header rows in TABLE to HB. */
 void
-table_set_hb (struct table *table, int hb)
+table_area_style_uninit (struct table_area_style *area)
 {
-  assert (!table_is_shared (table));
-  table->h[TABLE_VERT][1] = hb;
+  if (area)
+    font_style_uninit (&area->font_style);
 }
-
-/* Initializes TABLE as a table of the specified CLASS, initially with a
-   reference count of 1.
 
-   TABLE initially has 0 rows and columns and no headers.  The table
-   implementation should update the numbers of rows and columns.  The table
-   implementation (or its client) may update the header rows and columns.
+const char *
+table_stroke_to_string (enum table_stroke stroke)
+{
+  switch (stroke)
+    {
+    case TABLE_STROKE_NONE: return "none";
+    case TABLE_STROKE_SOLID: return "solid";
+    case TABLE_STROKE_DASHED: return "dashed";
+    case TABLE_STROKE_THICK: return "thick";
+    case TABLE_STROKE_THIN: return "thin";
+    case TABLE_STROKE_DOUBLE: return "double";
+    default:
+      return "**error**";
+    }
+}
 
-   A table is an abstract class, that is, a plain struct table is not useful on
-   its own.  Thus, this function is normally called from the initialization
-   function of some subclass of table. */
 void
-table_init (struct table *table, const struct table_class *class)
+cell_color_dump (const struct cell_color *c)
 {
-  table->klass = class;
-  table->n[TABLE_HORZ] = table->n[TABLE_VERT] = 0;
-  table->h[TABLE_HORZ][0] = table->h[TABLE_HORZ][1] = 0;
-  table->h[TABLE_VERT][0] = table->h[TABLE_VERT][1] = 0;
-  table->ref_cnt = 1;
+  if (c->alpha != 255)
+    printf ("rgba(%d, %d, %d, %d)", c->r, c->g, c->b, c->alpha);
+  else
+    printf ("#%02"PRIx8"%02"PRIx8"%02"PRIx8, c->r, c->g, c->b);
 }
 
-/* Sets the number of columns in TABLE to NC. */
 void
-table_set_nc (struct table *table, int nc)
+font_style_dump (const struct font_style *f)
 {
-  assert (!table_is_shared (table));
-  table->n[TABLE_HORZ] = nc;
+  printf ("%s %dpx ", f->typeface, f->size);
+  cell_color_dump (&f->fg[0]);
+  putchar ('/');
+  cell_color_dump (&f->bg[0]);
+  if (!cell_color_equal (f->fg[0], f->fg[1])
+      || !cell_color_equal (f->bg[0], f->bg[1]))
+    {
+      printf (" alt=");
+      cell_color_dump (&f->fg[1]);
+      putchar ('/');
+      cell_color_dump (&f->bg[1]);
+    }
+  if (f->bold)
+    fputs (" bold", stdout);
+  if (f->italic)
+    fputs (" italic", stdout);
+  if (f->underline)
+    fputs (" underline", stdout);
+}
+
+bool
+font_style_equal (const struct font_style *a, const struct font_style *b)
+{
+  return (a->bold == b->bold
+          && a->italic == b->italic
+          && a->underline == b->underline
+          && a->markup == b->markup
+          && cell_color_equal (a->fg[0], b->fg[0])
+          && cell_color_equal (a->fg[1], b->fg[1])
+          && cell_color_equal (a->bg[0], b->bg[0])
+          && cell_color_equal (a->bg[1], b->bg[1])
+          && !strcmp (a->typeface ? a->typeface : "",
+                      b->typeface ? b->typeface : "")
+          && a->size == b->size);
 }
 
-/* Sets the number of rows in TABLE to NR. */
 void
-table_set_nr (struct table *table, int nr)
+cell_style_dump (const struct cell_style *c)
 {
-  assert (!table_is_shared (table));
-  table->n[TABLE_VERT] = nr;
+  fputs (table_halign_to_string (c->halign), stdout);
+  if (c->halign == TABLE_HALIGN_DECIMAL)
+    printf ("(%.2gpx)", c->decimal_offset);
+  printf (" %s", table_valign_to_string (c->valign));
+  printf (" %d,%d,%d,%dpx",
+          c->margin[TABLE_HORZ][0], c->margin[TABLE_HORZ][1],
+          c->margin[TABLE_VERT][0], c->margin[TABLE_VERT][1]);
 }
 
-/* Initializes CELL with the contents of the table cell at column X and row Y
-   within TABLE.  When CELL is no longer needed, the caller is responsible for
-   freeing it by calling table_cell_free(CELL).
+/* Creates and returns a new table with NC columns and NR rows and initially no
+   header rows or columns.
 
-   The caller must ensure that CELL is destroyed before TABLE is unref'ed. */
+   Sets the number of header rows on each side of TABLE to HL on the
+   left, HT on the top.  Header rows
+   are repeated when a table is broken across multiple columns or
+   multiple pages.
+
+   The table's cells are initially empty. */
+struct table *
+table_create (int nc, int nr, int hl, int ht)
+{
+  struct pool *pool = pool_create ();
+  struct table *t = pool_alloc (pool, sizeof *t);
+  *t = (struct table) {
+    .container = pool,
+    .n = { [H] = nc, [V] = nr },
+    .h = { [H] = hl, [V] = ht },
+    .ref_cnt = 1,
+    .cc = pool_calloc (pool, nr * nc, sizeof *t->cc),
+    .cp = pool_calloc (pool, nr * nc, sizeof *t->cp),
+    .rh = pool_calloc (pool, nc, nr + 1),
+    .rv = pool_calloc (pool, nr, nc + 1),
+  };
+  return t;
+}
+
+/* Rules. */
+
+/* Draws a vertical line to the left of cells at horizontal position X
+   from Y1 to Y2 inclusive in style STYLE. */
 void
-table_get_cell (const struct table *table, int x, int y,
-                struct table_cell *cell)
+table_vline (struct table *t, int style, int x, int y1, int y2)
 {
-  assert (x >= 0 && x < table->n[TABLE_HORZ]);
-  assert (y >= 0 && y < table->n[TABLE_VERT]);
-  table->klass->get_cell (table, x, y, cell);
+  if (x < 0 || x > t->n[H] || y1 < 0 || y1 > y2 || y2 >= t->n[V])
+    {
+      printf ("bad vline: x=%d y=(%d,%d) in table size (%d,%d)\n",
+              x, y1, y2, t->n[H], t->n[V]);
+      abort ();
+    }
+
+  for (int y = y1; y <= y2; y++)
+    t->rv[x + (t->n[H] + 1) * y] = style;
 }
 
-/* Frees CELL, which should have been initialized by calling
-   table_get_cell(). */
+/* Draws a horizontal line above cells at vertical position Y from X1
+   to X2 inclusive in style STYLE. */
 void
-table_cell_free (struct table_cell *cell)
+table_hline (struct table *t, int style, int x1, int x2, int y)
 {
-  if (cell->destructor != NULL)
-    cell->destructor (cell->destructor_aux);
+  if (y < 0 || y > t->n[V] || x1 < 0 || x1 > x2 || x2 >= t->n[H])
+    {
+      printf ("bad hline: x=(%d,%d) y=%d in table size (%d,%d)\n",
+              x1, x2, y, t->n[H], t->n[V]);
+      abort ();
+    }
+
+  for (int x = x1; x <= x2; x++)
+    t->rh[x + t->n[H] * y] = style;
 }
+
+/* Cells. */
+
+/* Fill TABLE cells (X1,X2)-(Y1,Y2), inclusive, with VALUE and OPT. */
+void
+table_put (struct table *table, int x1, int y1, int x2, int y2,
+           unsigned int opt, const struct pivot_value *value)
+{
+  assert (0 <= x1 && x1 <= x2 && x2 < table->n[H]);
+  assert (0 <= y1 && y1 <= y2 && y2 < table->n[V]);
 
-/* Returns one of the TAL_* enumeration constants (declared in output/table.h)
-   representing a rule running alongside one of the cells in TABLE.
+  const bool debugging = false;
+  if (debugging)
+    {
+      printf ("put ");
+      if (x1 == x2)
+        printf ("%d", x1);
+      else
+        printf ("%d-%d", x1, x2);
+      printf (",");
+      if (y1 == y2)
+        printf ("%d", y1);
+      else
+        printf ("%d-%d", y1, y2);
+
+      char *value_s = value ? pivot_value_to_string (value, NULL) : NULL;
+      printf (": \"%s\"\n", value_s ? value_s : "");
+      free (value_s);
+    }
+
+  if (x1 == x2 && y1 == y2)
+    {
+      table->cc[x1 + y1 * table->n[H]] = CONST_CAST (struct pivot_value *, value);
+      table->cp[x1 + y1 * table->n[H]] = opt;
+    }
+  else
+    {
+      struct table_cell *cell = pool_alloc (table->container, sizeof *cell);
+      *cell = (struct table_cell) {
+        .d = { [H] = { x1, x2 + 1 }, [V] = { y1, y2 + 1 } },
+        .options = opt,
+        .value = value,
+      };
+
+      for (int y = y1; y <= y2; y++)
+        {
+          size_t ofs = x1 + y * table->n[H];
+          void **cc = &table->cc[ofs];
+          unsigned char *ct = &table->cp[ofs];
+          for (int x = x1; x <= x2; x++)
+            {
+              *cc++ = cell;
+              *ct++ = opt | TABLE_CELL_JOIN;
+            }
+        }
+    }
+}
+
+static void
+free_value (void *value_)
+{
+  struct pivot_value *value = value_;
+  pivot_value_destroy (value);
+}
+
+void
+table_put_owned (struct table *table, int x1, int y1, int x2, int y2,
+                 unsigned opt, struct pivot_value *value)
+{
+  table_put (table, x1, y1, x2, y2, opt, value);
+  pool_register (table->container, free_value, value);
+}
+
+/* Returns true if column C, row R has no contents, otherwise false. */
+bool
+table_cell_is_empty (const struct table *table, int c, int r)
+{
+  return table->cc[c + r * table->n[H]] == NULL;
+}
+
+/* Initializes CELL with the contents of the table cell at column X and row Y
+   within TABLE. */
+void
+table_get_cell (const struct table *t, int x, int y, struct table_cell *cell)
+{
+  assert (x >= 0 && x < t->n[TABLE_HORZ]);
+  assert (y >= 0 && y < t->n[TABLE_VERT]);
+
+  int index = x + y * t->n[H];
+  unsigned char opt = t->cp[index];
+  const void *cc = t->cc[index];
+
+  struct table_area_style *style
+    = t->styles[(opt & TABLE_CELL_STYLE_MASK) >> TABLE_CELL_STYLE_SHIFT];
+
+  static const struct pivot_value empty_value = {
+    .text = {
+      .type = PIVOT_VALUE_TEXT,
+      .local = (char *) "",
+      .c = (char *) "",
+      .id = (char *) "",
+      .user_provided = true,
+    },
+  };
+
+  if (opt & TABLE_CELL_JOIN)
+    {
+      const struct table_cell *jc = cc;
+      *cell = *jc;
+      if (!cell->value)
+        cell->value = &empty_value;
+      if (!cell->font_style)
+        cell->font_style = &style->font_style;
+      if (!cell->cell_style)
+        cell->cell_style = &style->cell_style;
+    }
+  else
+    {
+      const struct pivot_value *v = cc ? cc : &empty_value;
+      const struct pivot_value_ex *ex = pivot_value_ex (v);
+      *cell = (struct table_cell) {
+        .d = { [H] = { x, x + 1 }, [V] = { y, y + 1 } },
+        .options = opt,
+        .value = v,
+        .font_style = ex->font_style ? ex->font_style : &style->font_style,
+        .cell_style = ex->cell_style ? ex->cell_style : &style->cell_style,
+      };
+    }
+
+  assert (cell->font_style);
+  assert (cell->cell_style);
+}
+
+/* Returns one of the TABLE_STROKE_* enumeration constants (declared in
+   output/table.h) representing a rule running alongside one of the cells in
+   TABLE.
 
    Suppose NC is the number of columns in TABLE and NR is the number of rows.
    Then, if AXIS is TABLE_HORZ, then 0 <= X <= NC and 0 <= Y < NR.  If (X,Y) =
@@ -188,235 +476,17 @@ table_cell_free (struct table_cell *cell)
    the top of cell (0,0); if (X,Y) = (0,1), it is the horizontal rule
    between that cell and cell (0,1); and so on, up to (0,NR), which runs
    horizontally below cell (0,NR-1). */
-int
+struct table_border_style
 table_get_rule (const struct table *table, enum table_axis axis, int x, int y)
 {
   assert (x >= 0 && x < table->n[TABLE_HORZ] + (axis == TABLE_HORZ));
   assert (y >= 0 && y < table->n[TABLE_VERT] + (axis == TABLE_VERT));
-  return table->klass->get_rule (table, axis, x, y);
-}
-
-struct table_unshared
-  {
-    struct table table;
-    struct table *subtable;
-  };
-
-static const struct table_class table_unshared_class;
-
-/* Takes ownership of TABLE and returns a table with the same contents but
-   which is guaranteed not to be shared (as returned by table_is_shared()).
-
-   If TABLE is unshared, just returns TABLE.
-
-   The only real use for this function is to create a copy of TABLE in which
-   the headers can be adjusted, which is a pretty specialized use case. */
-struct table *
-table_unshare (struct table *table)
-{
-  if (!table_is_shared (table))
-    return table;
-  else
-    {
-      struct table_unshared *tiu = xmalloc (sizeof *tiu);
-      table_init (&tiu->table, &table_unshared_class);
-      table_set_nc (&tiu->table, table_nc (table));
-      table_set_nr (&tiu->table, table_nr (table));
-      table_set_hl (&tiu->table, table_hl (table));
-      table_set_hr (&tiu->table, table_hr (table));
-      table_set_ht (&tiu->table, table_ht (table));
-      table_set_hb (&tiu->table, table_hb (table));
-      tiu->subtable = table;
-      return &tiu->table;
-    }
-}
-
-static struct table_unshared *
-table_unshared_cast (const struct table *table)
-{
-  assert (table->klass == &table_unshared_class);
-  return UP_CAST (table, struct table_unshared, table);
-}
-
-static void
-table_unshared_destroy (struct table *tiu_)
-{
-  struct table_unshared *tiu = table_unshared_cast (tiu_);
-  table_unref (tiu->subtable);
-  free (tiu);
-}
-
-static void
-table_unshared_get_cell (const struct table *tiu_, int x, int y,
-                              struct table_cell *cell)
-{
-  struct table_unshared *tiu = table_unshared_cast (tiu_);
-  table_get_cell (tiu->subtable, x, y, cell);
-}
-
-static int
-table_unshared_get_rule (const struct table *tiu_,
-                              enum table_axis axis, int x, int y)
-{
-  struct table_unshared *tiu = table_unshared_cast (tiu_);
-  return table_get_rule (tiu->subtable, axis, x, y);
-}
-
-static const struct table_class table_unshared_class =
-  {
-    table_unshared_destroy,
-    table_unshared_get_cell,
-    table_unshared_get_rule,
-    NULL,                       /* paste */
-    NULL,                       /* select */
-  };
-
-struct table_string
-  {
-    struct table table;
-    char *string;
-    unsigned int options;
-  };
-
-static const struct table_class table_string_class;
-
-/* Returns a table that contains a single cell, whose contents are S with
-   options OPTIONS (a combination of TAB_* values).  */
-struct table *
-table_from_string (unsigned int options, const char *s)
-{
-  struct table_string *ts = xmalloc (sizeof *ts);
-  table_init (&ts->table, &table_string_class);
-  ts->table.n[TABLE_HORZ] = ts->table.n[TABLE_VERT] = 1;
-  ts->string = xstrdup (s);
-  ts->options = options;
-  return &ts->table;
-}
 
-static struct table_string *
-table_string_cast (const struct table *table)
-{
-  assert (table->klass == &table_string_class);
-  return UP_CAST (table, struct table_string, table);
-}
-
-static void
-table_string_destroy (struct table *ts_)
-{
-  struct table_string *ts = table_string_cast (ts_);
-  free (ts->string);
-  free (ts);
-}
-
-static void
-table_string_get_cell (const struct table *ts_, int x UNUSED, int y UNUSED,
-                       struct table_cell *cell)
-{
-  struct table_string *ts = table_string_cast (ts_);
-  cell->d[TABLE_HORZ][0] = 0;
-  cell->d[TABLE_HORZ][1] = 1;
-  cell->d[TABLE_VERT][0] = 0;
-  cell->d[TABLE_VERT][1] = 1;
-  cell->contents = &cell->inline_contents;
-  cell->inline_contents.options = ts->options;
-  cell->inline_contents.text = ts->string;
-  cell->inline_contents.table = NULL;
-  cell->inline_contents.n_footnotes = 0;
-  cell->n_contents = 1;
-  cell->destructor = NULL;
-}
-
-
-static int
-table_string_get_rule (const struct table *ts UNUSED,
-                       enum table_axis axis UNUSED, int x UNUSED, int y UNUSED)
-{
-  return TAL_0;
-}
-
-static const struct table_class table_string_class =
-  {
-    table_string_destroy,
-    table_string_get_cell,
-    table_string_get_rule,
-    NULL,                       /* paste */
-    NULL,                       /* select */
-  };
-
-struct table_nested
-  {
-    struct table table;
-    struct table_item *inner;
-  };
-
-static const struct table_class table_nested_class;
-
-/* Creates and returns a table with a single cell that contains INNER.
-   Takes ownership of INNER. */
-struct table *
-table_create_nested (struct table *inner)
-{
-  return table_create_nested_item (table_item_create (inner, NULL, NULL));
+  size_t border_idx = (axis == TABLE_VERT
+                      ? table->rh[x + table->n[H] * y]
+                      : table->rv[x + (table->n[H] + 1) * y]);
+  return (border_idx < table->n_borders
+          ? table->borders[border_idx]
+          : (struct table_border_style) { TABLE_STROKE_NONE,
+                                          CELL_COLOR_BLACK });
 }
-
-/* Creates and returns a table with a single cell that contains INNER.
-   Takes ownership of INNER. */
-struct table *
-table_create_nested_item (struct table_item *inner)
-{
-  struct table_nested *tn = xmalloc (sizeof *tn);
-  table_init (&tn->table, &table_nested_class);
-  tn->table.n[TABLE_HORZ] = tn->table.n[TABLE_VERT] = 1;
-  tn->inner = inner;
-  return &tn->table;
-}
-
-static struct table_nested *
-table_nested_cast (const struct table *table)
-{
-  assert (table->klass == &table_nested_class);
-  return UP_CAST (table, struct table_nested, table);
-}
-
-static void
-table_nested_destroy (struct table *tn_)
-{
-  struct table_nested *tn = table_nested_cast (tn_);
-  table_item_unref (tn->inner);
-  free (tn);
-}
-
-static void
-table_nested_get_cell (const struct table *tn_, int x UNUSED, int y UNUSED,
-                       struct table_cell *cell)
-{
-  struct table_nested *tn = table_nested_cast (tn_);
-  cell->d[TABLE_HORZ][0] = 0;
-  cell->d[TABLE_HORZ][1] = 1;
-  cell->d[TABLE_VERT][0] = 0;
-  cell->d[TABLE_VERT][1] = 1;
-  cell->contents = &cell->inline_contents;
-  cell->inline_contents.options = TAB_LEFT;
-  cell->inline_contents.text = NULL;
-  cell->inline_contents.table = tn->inner;
-  cell->inline_contents.n_footnotes = 0;
-  cell->n_contents = 1;
-  cell->destructor = NULL;
-}
-
-static int
-table_nested_get_rule (const struct table *tn UNUSED,
-                       enum table_axis axis UNUSED, int x UNUSED, int y UNUSED)
-{
-  return TAL_0;
-}
-
-static const struct table_class table_nested_class =
-  {
-    table_nested_destroy,
-    table_nested_get_cell,
-    table_nested_get_rule,
-    NULL,                       /* paste */
-    NULL,                       /* select */
-  };
-