Google Git
Sign in
gnu / gcc / aa1e672b5d99102b03eb5fb9c51609c45f62bff7 / . / gcc / text-art / table.cc
blob: 71a1024625761b842d8afb7bbc7dccefb1e65dc7 [file] [log] [blame]
/* Support for tabular/grid-based content.
Copyright (C) 2023 Free Software Foundation, Inc.
Contributed by David Malcolm <dmalcolm@redhat.com>.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
#include "config.h"
#define INCLUDE_MEMORY
#define INCLUDE_VECTOR
#include "system.h"
#include "coretypes.h"
#include "make-unique.h"
#include "pretty-print.h"
#include "diagnostic.h"
#include "selftest.h"
#include "text-art/selftests.h"
#include "text-art/table.h"
using namespace text_art;
/* class text_art::table_cell_content. */
table_cell_content::table_cell_content (styled_string &&s)
: m_str (std::move (s)),
/* We assume here that the content occupies a single canvas row. */
m_size (m_str.calc_canvas_width (), 1)
{
}
void
table_cell_content::paint_to_canvas (canvas &canvas,
canvas::coord_t top_left) const
{
canvas.paint_text (top_left, m_str);
}
/* struct text_art::table_dimension_sizes. */
table_dimension_sizes::table_dimension_sizes (unsigned num)
: m_requirements (num, 0)
{
}
/* class text_art::table::cell_placement. */
void
table::cell_placement::paint_cell_contents_to_canvas(canvas &canvas,
canvas::coord_t offset,
const table_geometry &tg) const
{
const canvas::size_t req_canvas_size = get_min_canvas_size ();
const canvas::size_t alloc_canvas_size = tg.get_canvas_size (m_rect);
gcc_assert (req_canvas_size.w <= alloc_canvas_size.w);
gcc_assert (req_canvas_size.h <= alloc_canvas_size.h);
const int x_padding = alloc_canvas_size.w - req_canvas_size.w;
const int y_padding = alloc_canvas_size.h - req_canvas_size.h;
const table::coord_t table_top_left = m_rect.m_top_left;
const canvas::coord_t canvas_top_left = tg.table_to_canvas (table_top_left);
gcc_assert (x_padding >= 0);
int x_align_offset;
switch (m_x_align)
{
default:
gcc_unreachable ();
case x_align::LEFT:
x_align_offset = 0;
break;
case x_align::CENTER:
x_align_offset = x_padding / 2;
break;
case x_align::RIGHT:
x_align_offset = x_padding;
break;
}
gcc_assert (y_padding >= 0);
int y_align_offset;
switch (m_y_align)
{
default:
gcc_unreachable ();
case y_align::TOP:
y_align_offset = 0;
break;
case y_align::CENTER:
y_align_offset = y_padding / 2;
break;
case y_align::BOTTOM:
y_align_offset = y_padding;
break;
}
const canvas::coord_t content_rel_coord
(canvas_top_left.x + 1 + x_align_offset,
canvas_top_left.y + 1 + y_align_offset);
m_content.paint_to_canvas (canvas, offset + content_rel_coord);
}
/* class text_art::table. */
table::table (size_t size)
: m_size (size),
m_placements (),
m_occupancy (size)
{
m_occupancy.fill (-1);
}
void
table::set_cell (coord_t coord,
table_cell_content &&content,
enum x_align x_align,
enum y_align y_align)
{
set_cell_span (rect_t (coord, table::size_t (1, 1)),
std::move (content), x_align, y_align);
}
void
table::set_cell_span (rect_t span,
table_cell_content &&content,
enum x_align x_align,
enum y_align y_align)
{
gcc_assert (span.m_size.w > 0);
gcc_assert (span.m_size.h > 0);
int placement_idx = m_placements.size ();
m_placements.emplace_back (cell_placement (span, std::move (content),
x_align, y_align));
for (int y = span.get_min_y (); y < span.get_next_y (); y++)
for (int x = span.get_min_x (); x < span.get_next_x (); x++)
{
gcc_assert (m_occupancy.get (coord_t (x, y)) == -1);
m_occupancy.set (coord_t (x, y), placement_idx);
}
}
canvas
table::to_canvas (const theme &theme, const style_manager &sm) const
{
table_dimension_sizes col_widths (m_size.w);
table_dimension_sizes row_heights (m_size.h);
table_cell_sizes cell_sizes (col_widths, row_heights);
cell_sizes.pass_1 (*this);
cell_sizes.pass_2 (*this);
table_geometry tg (*this, cell_sizes);
canvas canvas (tg.get_canvas_size (), sm);
paint_to_canvas (canvas, canvas::coord_t (0, 0), tg, theme);
return canvas;
}
void
table::paint_to_canvas (canvas &canvas,
canvas::coord_t offset,
const table_geometry &tg,
const theme &theme) const
{
canvas.fill (canvas::rect_t (offset, tg.get_canvas_size ()),
styled_unichar (' '));
paint_cell_borders_to_canvas (canvas, offset, tg, theme);
paint_cell_contents_to_canvas (canvas, offset, tg);
}
/* Print this table to stderr. */
DEBUG_FUNCTION void
table::debug () const
{
/* Use a temporary style manager.
Styles in the table will be meaningless, so
print the canvas with styling disabled. */
style_manager sm;
canvas canvas (to_canvas (unicode_theme (), sm));
canvas.debug (false);
}
const table::cell_placement *
table::get_placement_at (coord_t coord) const
{
const int placement_idx = m_occupancy.get (coord);
if (placement_idx == -1)
return nullptr;
return &m_placements[placement_idx];
}
int
table::get_occupancy_safe (coord_t coord) const
{
if (coord.x < 0)
return -1;
if (coord.x >= m_size.w)
return -1;
if (coord.y < 0)
return -1;
if (coord.y >= m_size.h)
return -1;
return m_occupancy.get (coord);
}
/* Determine if the "?" edges need borders for table cell D
in the following, for the directions relative to "X", based
on whether each of table cell boundaries AB, CD, AC, and BD
are boundaries between cell spans:
# up?
# +-----+-----+
# | |
# | ? |
# | A ? B |
# | ? |
# | |
# left?+ ??? X ??? + right?
# | |
# | ? |
# | C ? D |
# | ? |
# | |
# +-----+-----+
# down?
*/
directions
table::get_connections (int table_x, int table_y) const
{
int cell_a = get_occupancy_safe (coord_t (table_x - 1, table_y - 1));
int cell_b = get_occupancy_safe (coord_t (table_x, table_y - 1));
int cell_c = get_occupancy_safe (coord_t (table_x - 1, table_y));
int cell_d = get_occupancy_safe (coord_t (table_x, table_y));
const bool up = (cell_a != cell_b);
const bool down = (cell_c != cell_d);
const bool left = (cell_a != cell_c);
const bool right = (cell_b != cell_d);
return directions (up, down, left, right);
}
/* Paint the grid lines.
Consider painting
- a grid of cells,
- plus a right-hand border
- and a bottom border
Then we need to paint to the canvas like this:
# PER-TABLE-COLUMN R BORDER
# +-------------------+ +-----+
#
# TABLE CELL WIDTH (in canvas units)
# +-------------+
# . . . . . . .
# ...+-----+-----+.+-----+...+-----+ +
# | U | |.| | | U | |
# | U | |.| | | U | |
# |LL+RR|RRRRR|.|RRRRR| |LL+ | |
# | D | |.| | | D | |
# | D | |.| | | D | |
# ...+-----+-----+.+-----+...+-----+ |
# ..................... ...... +-- PER-TABLE-ROW
# ...+-----+-----+.+-----+...+-----+ | +
# | D | |.| | | D | | |
# | D | |.| | | D | | |
# | D | |.| | | D | | +---- TABLE CELL HEIGHT (in canvas units)
# | D | |.| | | D | | |
# | D | |.| | | D | | |
# ...+-----+-----+.+-----+...+-----+ + +
# . . . . . .
# ...+-----+-----+.+-----+...+-----+ +
# | D | |.| | | U | |
# | D | |.| | | U | |
# |LL+RR|RRRRR|.|RRRRR| |LL+ | | BOTTOM BORDER
# | | |.| | | | |
# | | |.| | | | |
# ...+-----+-----+.+-----+...+-----+ +
where each:
# +-----+
# | |
# | |
# | |
# | |
# | |
# +-----+
is a canvas cell, and the U, L, R, D express the connections
that are present with neighboring table cells. These affect
the kinds of borders that we draw for a particular table cell. */
void
table::paint_cell_borders_to_canvas (canvas &canvas,
canvas::coord_t offset,
const table_geometry &tg,
const theme &theme) const
{
/* The per-table-cell left and top borders are either drawn or not,
but if they are, they aren't affected by per-table-cell connections. */
const canvas::cell_t left_border
= theme.get_line_art (directions (true, /* up */
true, /* down */
false, /* left */
false /* right */));
const canvas::cell_t top_border
= theme.get_line_art (directions (false, /* up */
false, /* down */
true, /* left */
true)); /* right */
for (int table_y = 0; table_y < m_size.h; table_y++)
{
const int canvas_y = tg.table_y_to_canvas_y (table_y);
for (int table_x = 0; table_x < m_size.w; table_x++)
{
canvas::coord_t canvas_top_left
= tg.table_to_canvas(table::coord_t (table_x, table_y));
const directions c (get_connections (table_x, table_y));
/* Paint top-left corner of border, if any. */
canvas.paint (offset + canvas_top_left,
theme.get_line_art (c));
/* Paint remainder of left border of cell, if any.
We assume here that the content occupies a single canvas row. */
if (c.m_down)
canvas.paint (offset + canvas::coord_t (canvas_top_left.x,
canvas_y + 1),
left_border);
/* Paint remainder of top border of cell, if any. */
if (c.m_right)
{
const int col_width = tg.get_col_width (table_x);
for (int x_offset = 0; x_offset < col_width; x_offset++)
{
const int canvas_x = canvas_top_left.x + 1 + x_offset;
canvas.paint (offset + canvas::coord_t (canvas_x, canvas_y),
top_border);
}
}
}
/* Paint right-hand border of row. */
const int table_x = m_size.w;
const int canvas_x = tg.table_x_to_canvas_x (table_x);
const directions c (get_connections (m_size.w, table_y));
canvas.paint(offset + canvas::coord_t (canvas_x, canvas_y),
theme.get_line_art (directions (c.m_up,
c.m_down,
c.m_left,
false))); /* right */
/* We assume here that the content occupies a single canvas row. */
canvas.paint(offset + canvas::coord_t (canvas_x, canvas_y + 1),
theme.get_line_art (directions (c.m_down, /* up */
c.m_down, /* down */
false, /* left */
false))); /* right */
}
/* Draw bottom border of table. */
{
const int canvas_y = tg.get_canvas_size ().h - 1;
for (int table_x = 0; table_x < m_size.w; table_x++)
{
const directions c (get_connections (table_x, m_size.h));
const int left_canvas_x = tg.table_x_to_canvas_x (table_x);
canvas.paint (offset + canvas::coord_t (left_canvas_x, canvas_y),
theme.get_line_art (directions (c.m_up,
false, /* down */
c.m_left,
c.m_right)));
const int col_width = tg.get_col_width (table_x);
for (int x_offset = 0; x_offset < col_width; x_offset++)
{
const int canvas_x = left_canvas_x + 1 + x_offset;
canvas.paint(offset + canvas::coord_t (canvas_x, canvas_y),
theme.get_line_art (directions (false, // up
false, // down
c.m_right, // left
c.m_right))); // right
}
}
/* Bottom-right corner of table. */
const int table_x = m_size.w;
const int canvas_x = tg.table_x_to_canvas_x (table_x);
const directions c (get_connections (m_size.w, m_size.h));
canvas.paint (offset + canvas::coord_t (canvas_x, canvas_y),
theme.get_line_art (directions (c.m_up, // up
false, // down
c.m_left, // left
false))); // right
}
}
void
table::paint_cell_contents_to_canvas(canvas &canvas,
canvas::coord_t offset,
const table_geometry &tg) const
{
for (auto &placement : m_placements)
placement.paint_cell_contents_to_canvas (canvas, offset, tg);
}
/* class table_cell_sizes. */
/* Consider 1x1 cells. */
void
table_cell_sizes::pass_1 (const table &table)
{
for (auto &placement : table.m_placements)
if (placement.one_by_one_p ())
{
canvas::size_t canvas_size (placement.get_min_canvas_size ());
table::coord_t table_coord (placement.m_rect.m_top_left);
m_col_widths.require (table_coord.x, canvas_size.w);
m_row_heights.require (table_coord.y, canvas_size.h);
}
}
/* Consider cells that span more than one row or column. */
void
table_cell_sizes::pass_2 (const table &table)
{
for (auto &placement : table.m_placements)
if (!placement.one_by_one_p ())
{
const canvas::size_t req_canvas_size (placement.get_min_canvas_size ());
const canvas::size_t current_canvas_size
= get_canvas_size (placement.m_rect);
/* Grow columns as necessary. */
if (req_canvas_size.w > current_canvas_size.w)
{
/* Spread the deficit amongst the columns. */
int deficit = req_canvas_size.w - current_canvas_size.w;
const int per_col = deficit / placement.m_rect.m_size.w;
for (int table_x = placement.m_rect.get_min_x ();
table_x < placement.m_rect.get_next_x ();
table_x++)
{
m_col_widths.m_requirements[table_x] += per_col;
deficit -= per_col;
}
/* Make sure we allocate all of the deficit. */
if (deficit > 0)
{
const int table_x = placement.m_rect.get_max_x ();
m_col_widths.m_requirements[table_x] += deficit;
}
}
/* Grow rows as necessary. */
if (req_canvas_size.h > current_canvas_size.h)
{
/* Spread the deficit amongst the rows. */
int deficit = req_canvas_size.h - current_canvas_size.h;
const int per_row = deficit / placement.m_rect.m_size.h;
for (int table_y = placement.m_rect.get_min_y ();
table_y < placement.m_rect.get_next_y ();
table_y++)
{
m_row_heights.m_requirements[table_y] += per_row;
deficit -= per_row;
}
/* Make sure we allocate all of the deficit. */
if (deficit > 0)
{
const int table_y = placement.m_rect.get_max_y ();
m_row_heights.m_requirements[table_y] += deficit;
}
}
}
}
canvas::size_t
table_cell_sizes::get_canvas_size (const table::rect_t &rect) const
{
canvas::size_t result (0, 0);
for (int table_x = rect.get_min_x ();
table_x < rect.get_next_x ();
table_x ++)
result.w += m_col_widths.m_requirements[table_x];
for (int table_y = rect.get_min_y ();
table_y < rect.get_next_y ();
table_y ++)
result.h += m_row_heights.m_requirements[table_y];
/* Allow space for the borders. */
result.w += rect.m_size.w - 1;
result.h += rect.m_size.h - 1;
return result;
}
/* class text_art::table_geometry. */
table_geometry::table_geometry (const table &table, table_cell_sizes &cell_sizes)
: m_table (table),
m_cell_sizes (cell_sizes),
m_canvas_size (canvas::size_t (0, 0)),
m_col_start_x (table.get_size ().w),
m_row_start_y (table.get_size ().h)
{
recalc_coords ();
}
void
table_geometry::recalc_coords ()
{
/* Start canvas column of table cell, including leading border. */
m_col_start_x.clear ();
int iter_canvas_x = 0;
for (auto w : m_cell_sizes.m_col_widths.m_requirements)
{
m_col_start_x.push_back (iter_canvas_x);
iter_canvas_x += w + 1;
}
/* Start canvas row of table cell, including leading border. */
m_row_start_y.clear ();
int iter_canvas_y = 0;
for (auto h : m_cell_sizes.m_row_heights.m_requirements)
{
m_row_start_y.push_back (iter_canvas_y);
iter_canvas_y += h + 1;
}
m_canvas_size = canvas::size_t (iter_canvas_x + 1,
iter_canvas_y + 1);
}
/* Get the TL corner of the table cell at TABLE_COORD
in canvas coords (including the border). */
canvas::coord_t
table_geometry::table_to_canvas (table::coord_t table_coord) const
{
return canvas::coord_t (table_x_to_canvas_x (table_coord.x),
table_y_to_canvas_y (table_coord.y));
}
/* Get the left border of the table cell at column TABLE_X
in canvas coords (including the border). */
int
table_geometry::table_x_to_canvas_x (int table_x) const
{
/* Allow one beyond the end, for the right-hand border of the table. */
if (table_x == m_col_start_x.size ())
return m_canvas_size.w - 1;
return m_col_start_x[table_x];
}
/* Get the top border of the table cell at column TABLE_Y
in canvas coords (including the border). */
int
table_geometry::table_y_to_canvas_y (int table_y) const
{
/* Allow one beyond the end, for the right-hand border of the table. */
if (table_y == m_row_start_y.size ())
return m_canvas_size.h - 1;
return m_row_start_y[table_y];
}
/* class text_art::simple_table_geometry. */
simple_table_geometry::simple_table_geometry (const table &table)
: m_col_widths (table.get_size ().w),
m_row_heights (table.get_size ().h),
m_cell_sizes (m_col_widths, m_row_heights),
m_tg (table, m_cell_sizes)
{
m_cell_sizes.pass_1 (table);
m_cell_sizes.pass_2 (table);
m_tg.recalc_coords ();
}
#if CHECKING_P
namespace selftest {
static void
test_tic_tac_toe ()
{
style_manager sm;
table t (table::size_t (3, 3));
t.set_cell (table::coord_t (0, 0), styled_string (sm, "X"));
t.set_cell (table::coord_t (1, 0), styled_string (sm, ""));
t.set_cell (table::coord_t (2, 0), styled_string (sm, ""));
t.set_cell (table::coord_t (0, 1), styled_string (sm, "O"));
t.set_cell (table::coord_t (1, 1), styled_string (sm, "O"));
t.set_cell (table::coord_t (2, 1), styled_string (sm, ""));
t.set_cell (table::coord_t (0, 2), styled_string (sm, "X"));
t.set_cell (table::coord_t (1, 2), styled_string (sm, ""));
t.set_cell (table::coord_t (2, 2), styled_string (sm, "O"));
{
canvas canvas (t.to_canvas (ascii_theme (), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+-+-+-+\n"
"|X| | |\n"
"+-+-+-+\n"
"|O|O| |\n"
"+-+-+-+\n"
"|X| |O|\n"
"+-+-+-+\n"));
}
{
canvas canvas (t.to_canvas (unicode_theme (), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌─┬─┬─┐\n"
"│X│ │ │\n"
"├─┼─┼─┤\n"
"│O│O│ │\n"
"├─┼─┼─┤\n"
"│X│ │O│\n"
"└─┴─┴─┘\n"));
}
}
static table
make_text_table ()
{
style_manager sm;
table t (table::size_t (3, 3));
t.set_cell (table::coord_t (0, 0), styled_string (sm, "top left"));
t.set_cell (table::coord_t (1, 0), styled_string (sm, "top middle"));
t.set_cell (table::coord_t (2, 0), styled_string (sm, "top right"));
t.set_cell (table::coord_t (0, 1), styled_string (sm, "middle left"));
t.set_cell (table::coord_t (1, 1), styled_string (sm, "middle middle"));
t.set_cell (table::coord_t (2, 1), styled_string (sm, "middle right"));
t.set_cell (table::coord_t (0, 2), styled_string (sm, "bottom left"));
t.set_cell (table::coord_t (1, 2), styled_string (sm, "bottom middle"));
t.set_cell (table::coord_t (2, 2), styled_string (sm, "bottom right"));
return t;
}
static void
test_text_table ()
{
style_manager sm;
table table = make_text_table ();
{
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+-----------+-------------+------------+\n"
"| top left | top middle | top right |\n"
"+-----------+-------------+------------+\n"
"|middle left|middle middle|middle right|\n"
"+-----------+-------------+------------+\n"
"|bottom left|bottom middle|bottom right|\n"
"+-----------+-------------+------------+\n"));
}
{
canvas canvas (table.to_canvas (unicode_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌───────────┬─────────────┬────────────┐\n"
"│ top left │ top middle │ top right │\n"
"├───────────┼─────────────┼────────────┤\n"
"│middle left│middle middle│middle right│\n"
"├───────────┼─────────────┼────────────┤\n"
"│bottom left│bottom middle│bottom right│\n"
"└───────────┴─────────────┴────────────┘\n"));
}
}
static void
test_offset_table ()
{
style_manager sm;
table table = make_text_table ();
simple_table_geometry stg (table);
const canvas::size_t tcs = stg.m_tg.get_canvas_size();
{
canvas canvas (canvas::size_t (tcs.w + 5, tcs.h + 5), sm);
canvas.debug_fill ();
table.paint_to_canvas (canvas, canvas::coord_t (3, 3),
stg.m_tg,
ascii_theme());
ASSERT_CANVAS_STREQ
(canvas, false,
("*********************************************\n"
"*********************************************\n"
"*********************************************\n"
"***+-----------+-------------+------------+**\n"
"***| top left | top middle | top right |**\n"
"***+-----------+-------------+------------+**\n"
"***|middle left|middle middle|middle right|**\n"
"***+-----------+-------------+------------+**\n"
"***|bottom left|bottom middle|bottom right|**\n"
"***+-----------+-------------+------------+**\n"
"*********************************************\n"
"*********************************************\n"));
}
{
canvas canvas (canvas::size_t (tcs.w + 5, tcs.h + 5), sm);
canvas.debug_fill ();
table.paint_to_canvas (canvas, canvas::coord_t (3, 3),
stg.m_tg,
unicode_theme());
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("*********************************************\n"
"*********************************************\n"
"*********************************************\n"
"***┌───────────┬─────────────┬────────────┐**\n"
"***│ top left │ top middle │ top right │**\n"
"***├───────────┼─────────────┼────────────┤**\n"
"***│middle left│middle middle│middle right│**\n"
"***├───────────┼─────────────┼────────────┤**\n"
"***│bottom left│bottom middle│bottom right│**\n"
"***└───────────┴─────────────┴────────────┘**\n"
"*********************************************\n"
"*********************************************\n"));
}
}
#define ASSERT_TABLE_CELL_STREQ(TABLE, TABLE_X, TABLE_Y, EXPECTED_STR) \
SELFTEST_BEGIN_STMT \
table::coord_t coord ((TABLE_X), (TABLE_Y)); \
const table::cell_placement *cp = (TABLE).get_placement_at (coord); \
ASSERT_NE (cp, nullptr); \
ASSERT_EQ (cp->get_content (), styled_string (sm, EXPECTED_STR)); \
SELFTEST_END_STMT
#define ASSERT_TABLE_NULL_CELL(TABLE, TABLE_X, TABLE_Y) \
SELFTEST_BEGIN_STMT \
table::coord_t coord ((TABLE_X), (TABLE_Y)); \
const table::cell_placement *cp = (TABLE).get_placement_at (coord); \
ASSERT_EQ (cp, nullptr); \
SELFTEST_END_STMT
static void
test_spans ()
{
style_manager sm;
table table (table::size_t (3, 3));
table.set_cell_span (table::rect_t (table::coord_t (0, 0),
table::size_t (3, 1)),
styled_string (sm, "ABC"));
table.set_cell_span (table::rect_t (table::coord_t (0, 1),
table::size_t (2, 1)),
styled_string (sm, "DE"));
table.set_cell_span (table::rect_t (table::coord_t (2, 1),
table::size_t (1, 1)),
styled_string (sm, "F"));
table.set_cell (table::coord_t (0, 2), styled_string (sm, "G"));
table.set_cell (table::coord_t (1, 2), styled_string (sm, "H"));
table.set_cell (table::coord_t (2, 2), styled_string (sm, "I"));
{
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+-----+\n"
"| ABC |\n"
"+---+-+\n"
"|DE |F|\n"
"+-+-+-+\n"
"|G|H|I|\n"
"+-+-+-+\n"));
}
{
canvas canvas (table.to_canvas (unicode_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌─────┐\n"
"│ ABC │\n"
"├───┬─┤\n"
"│DE │F│\n"
"├─┬─┼─┤\n"
"│G│H│I│\n"
"└─┴─┴─┘\n"));
}
}
/* Verify building this 5x5 table with spans:
|0|1|2|3|4|
+-+-+-+-+-+
0|A A A|B|C|0
+ +-+ +
1|A A A|D|C|1
+ +-+-+
2|A A A|E|F|2
+-+-+-+-+-+
3|G G|H|I I|3
| | +-+-+
4|G G|H|J J|4
+-+-+-+-+-+
|0|1|2|3|4|
*/
static void
test_spans_2 ()
{
style_manager sm;
table table (table::size_t (5, 5));
table.set_cell_span (table::rect_t (table::coord_t (0, 0),
table::size_t (3, 3)),
styled_string (sm, "A"));
table.set_cell_span (table::rect_t (table::coord_t (3, 0),
table::size_t (1, 1)),
styled_string (sm, "B"));
table.set_cell_span (table::rect_t (table::coord_t (4, 0),
table::size_t (1, 2)),
styled_string (sm, "C"));
table.set_cell_span (table::rect_t (table::coord_t (3, 1),
table::size_t (1, 1)),
styled_string (sm, "D"));
table.set_cell_span (table::rect_t (table::coord_t (3, 2),
table::size_t (1, 1)),
styled_string (sm, "E"));
table.set_cell_span (table::rect_t (table::coord_t (4, 2),
table::size_t (1, 1)),
styled_string (sm, "F"));
table.set_cell_span (table::rect_t (table::coord_t (0, 3),
table::size_t (2, 2)),
styled_string (sm, "G"));
table.set_cell_span (table::rect_t (table::coord_t (2, 3),
table::size_t (1, 2)),
styled_string (sm, "H"));
table.set_cell_span (table::rect_t (table::coord_t (3, 3),
table::size_t (2, 1)),
styled_string (sm, "I"));
table.set_cell_span (table::rect_t (table::coord_t (3, 4),
table::size_t (2, 1)),
styled_string (sm, "J"));
/* Check occupancy at each table coordinate. */
ASSERT_TABLE_CELL_STREQ (table, 0, 0, "A");
ASSERT_TABLE_CELL_STREQ (table, 1, 0, "A");
ASSERT_TABLE_CELL_STREQ (table, 2, 0, "A");
ASSERT_TABLE_CELL_STREQ (table, 3, 0, "B");
ASSERT_TABLE_CELL_STREQ (table, 4, 0, "C");
ASSERT_TABLE_CELL_STREQ (table, 0, 1, "A");
ASSERT_TABLE_CELL_STREQ (table, 1, 1, "A");
ASSERT_TABLE_CELL_STREQ (table, 2, 1, "A");
ASSERT_TABLE_CELL_STREQ (table, 3, 1, "D");
ASSERT_TABLE_CELL_STREQ (table, 4, 1, "C");
ASSERT_TABLE_CELL_STREQ (table, 0, 2, "A");
ASSERT_TABLE_CELL_STREQ (table, 1, 2, "A");
ASSERT_TABLE_CELL_STREQ (table, 2, 2, "A");
ASSERT_TABLE_CELL_STREQ (table, 3, 2, "E");
ASSERT_TABLE_CELL_STREQ (table, 4, 2, "F");
ASSERT_TABLE_CELL_STREQ (table, 0, 3, "G");
ASSERT_TABLE_CELL_STREQ (table, 1, 3, "G");
ASSERT_TABLE_CELL_STREQ (table, 2, 3, "H");
ASSERT_TABLE_CELL_STREQ (table, 3, 3, "I");
ASSERT_TABLE_CELL_STREQ (table, 4, 3, "I");
ASSERT_TABLE_CELL_STREQ (table, 0, 4, "G");
ASSERT_TABLE_CELL_STREQ (table, 1, 4, "G");
ASSERT_TABLE_CELL_STREQ (table, 2, 4, "H");
ASSERT_TABLE_CELL_STREQ (table, 3, 4, "J");
ASSERT_TABLE_CELL_STREQ (table, 4, 4, "J");
{
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+---+-+-+\n"
"| |B| |\n"
"| +-+C|\n"
"| A |D| |\n"
"| +-+-+\n"
"| |E|F|\n"
"+-+-+-+-+\n"
"| | | I |\n"
"|G|H+---+\n"
"| | | J |\n"
"+-+-+---+\n"));
}
{
canvas canvas (table.to_canvas (unicode_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌───┬─┬─┐\n"
"│ │B│ │\n"
"│ ├─┤C│\n"
"│ A │D│ │\n"
"│ ├─┼─┤\n"
"│ │E│F│\n"
"├─┬─┼─┴─┤\n"
"│ │ │ I │\n"
"│G│H├───┤\n"
"│ │ │ J │\n"
"└─┴─┴───┘\n"));
}
}
/* Experiment with adding a 1-table-column gap at the boundary between
valid vs invalid for visualizing a buffer overflow. */
static void
test_spans_3 ()
{
const char * const str = "hello world!";
const size_t buf_size = 10;
const size_t str_size = strlen (str) + 1;
style_manager sm;
table table (table::size_t (str_size + 1, 3));
table.set_cell_span (table::rect_t (table::coord_t (0, 0),
table::size_t (str_size + 1, 1)),
styled_string (sm, "String literal"));
for (size_t i = 0; i < str_size; i++)
{
table::coord_t c (i, 1);
if (i >= buf_size)
c.x++;
if (str[i] == '\0')
table.set_cell (c, styled_string (sm, "NUL"));
else
table.set_cell (c, styled_string ((cppchar_t)str[i]));
}
table.set_cell_span (table::rect_t (table::coord_t (0, 2),
table::size_t (buf_size, 1)),
styled_string::from_fmt (sm,
nullptr,
"'buf' (char[%i])",
(int)buf_size));
table.set_cell_span (table::rect_t (table::coord_t (buf_size + 1, 2),
table::size_t (str_size - buf_size, 1)),
styled_string (sm, "overflow"));
{
canvas canvas (table.to_canvas (ascii_theme (), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
"+-----------------------------+\n"
"| String literal |\n"
"+-+-+-+-+-+-+-+-+-+-++-+-+----+\n"
"|h|e|l|l|o| |w|o|r|l||d|!|NUL |\n"
"+-+-+-+-+-+-+-+-+-+-++-+-+----+\n"
"| 'buf' (char[10]) ||overflow|\n"
"+-------------------++--------+\n");
}
{
canvas canvas (table.to_canvas (unicode_theme (), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌─────────────────────────────┐\n"
"│ String literal │\n"
"├─┬─┬─┬─┬─┬─┬─┬─┬─┬─┬┬─┬─┬────┤\n"
"│h│e│l│l│o│ │w│o│r│l││d│!│NUL │\n"
"├─┴─┴─┴─┴─┴─┴─┴─┴─┴─┤├─┴─┴────┤\n"
"│ 'buf' (char[10]) ││overflow│\n"
"└───────────────────┘└────────┘\n"));
}
}
static void
test_double_width_chars ()
{
table_cell_content tcc (styled_string ((cppchar_t)0x1f642));
ASSERT_EQ (tcc.get_canvas_size ().w, 2);
ASSERT_EQ (tcc.get_canvas_size ().h, 1);
style_manager sm;
table table (table::size_t (1, 1));
table.set_cell (table::coord_t (0,0),
styled_string ((cppchar_t)0x1f642));
canvas canvas (table.to_canvas (unicode_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌──┐\n"
"│🙂│\n"
"└──┘\n"));
}
static void
test_ipv4_header ()
{
style_manager sm;
table table (table::size_t (34, 10));
table.set_cell (table::coord_t (0, 0), styled_string (sm, "Offsets"));
table.set_cell (table::coord_t (1, 0), styled_string (sm, "Octet"));
table.set_cell (table::coord_t (0, 1), styled_string (sm, "Octet"));
for (int octet = 0; octet < 4; octet++)
table.set_cell_span (table::rect_t (table::coord_t (2 + (octet * 8), 0),
table::size_t (8, 1)),
styled_string::from_fmt (sm, nullptr, "%i", octet));
table.set_cell (table::coord_t (1, 1), styled_string (sm, "Bit"));
for (int bit = 0; bit < 32; bit++)
table.set_cell (table::coord_t (bit + 2, 1),
styled_string::from_fmt (sm, nullptr, "%i", bit));
for (int word = 0; word < 6; word++)
{
table.set_cell (table::coord_t (0, word + 2),
styled_string::from_fmt (sm, nullptr, "%i", word * 4));
table.set_cell (table::coord_t (1, word + 2),
styled_string::from_fmt (sm, nullptr, "%i", word * 32));
}
table.set_cell (table::coord_t (0, 8), styled_string (sm, "..."));
table.set_cell (table::coord_t (1, 8), styled_string (sm, "..."));
table.set_cell (table::coord_t (0, 9), styled_string (sm, "56"));
table.set_cell (table::coord_t (1, 9), styled_string (sm, "448"));
#define SET_BITS(FIRST, LAST, NAME) \
do { \
const int first = (FIRST); \
const int last = (LAST); \
const char *name = (NAME); \
const int row = first / 32; \
gcc_assert (last / 32 == row); \
table::rect_t rect (table::coord_t ((first % 32) + 2, row + 2), \
table::size_t (last + 1 - first , 1)); \
table.set_cell_span (rect, styled_string (sm, name)); \
} while (0)
SET_BITS (0, 3, "Version");
SET_BITS (4, 7, "IHL");
SET_BITS (8, 13, "DSCP");
SET_BITS (14, 15, "ECN");
SET_BITS (16, 31, "Total Length");
SET_BITS (32 + 0, 32 + 15, "Identification");
SET_BITS (32 + 16, 32 + 18, "Flags");
SET_BITS (32 + 19, 32 + 31, "Fragment Offset");
SET_BITS (64 + 0, 64 + 7, "Time To Live");
SET_BITS (64 + 8, 64 + 15, "Protocol");
SET_BITS (64 + 16, 64 + 31, "Header Checksum");
SET_BITS (96 + 0, 96 + 31, "Source IP Address");
SET_BITS (128 + 0, 128 + 31, "Destination IP Address");
table.set_cell_span(table::rect_t (table::coord_t (2, 7),
table::size_t (32, 3)),
styled_string (sm, "Options"));
{
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+-------+-----+---------------+---------------------+-----------------------+-----------------------+\n"
"|Offsets|Octet| 0 | 1 | 2 | 3 |\n"
"+-------+-----+-+-+-+-+-+-+-+-+-+-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n"
"| Octet | Bit |0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|\n"
"+-------+-----+-+-+-+-+-+-+-+-+-+-+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+\n"
"| 0 | 0 |Version| IHL | DSCP | ECN | Total Length |\n"
"+-------+-----+-------+-------+---------------+-----+--------+--------------------------------------+\n"
"| 4 | 32 | Identification | Flags | Fragment Offset |\n"
"+-------+-----+---------------+---------------------+--------+--------------------------------------+\n"
"| 8 | 64 | Time To Live | Protocol | Header Checksum |\n"
"+-------+-----+---------------+---------------------+-----------------------------------------------+\n"
"| 12 | 96 | Source IP Address |\n"
"+-------+-----+-------------------------------------------------------------------------------------+\n"
"| 16 | 128 | Destination IP Address |\n"
"+-------+-----+-------------------------------------------------------------------------------------+\n"
"| 20 | 160 | |\n"
"+-------+-----+ |\n"
"| ... | ... | Options |\n"
"+-------+-----+ |\n"
"| 56 | 448 | |\n"
"+-------+-----+-------------------------------------------------------------------------------------+\n"));
}
{
canvas canvas (table.to_canvas (unicode_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
// FIXME: are we allowed unicode chars in string literals in our source?
("┌───────┬─────┬───────────────┬─────────────────────┬───────────────────────┬───────────────────────┐\n"
"│Offsets│Octet│ 0 │ 1 │ 2 │ 3 │\n"
"├───────┼─────┼─┬─┬─┬─┬─┬─┬─┬─┼─┬─┬──┬──┬──┬──┬──┬──┼──┬──┬──┬──┬──┬──┬──┬──┼──┬──┬──┬──┬──┬──┬──┬──┤\n"
"│ Octet │ Bit │0│1│2│3│4│5│6│7│8│9│10│11│12│13│14│15│16│17│18│19│20│21│22│23│24│25│26│27│28│29│30│31│\n"
"├───────┼─────┼─┴─┴─┴─┼─┴─┴─┴─┼─┴─┴──┴──┴──┴──┼──┴──┼──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┤\n"
"│ 0 │ 0 │Version│ IHL │ DSCP │ ECN │ Total Length │\n"
"├───────┼─────┼───────┴───────┴───────────────┴─────┼────────┬──────────────────────────────────────┤\n"
"│ 4 │ 32 │ Identification │ Flags │ Fragment Offset │\n"
"├───────┼─────┼───────────────┬─────────────────────┼────────┴──────────────────────────────────────┤\n"
"│ 8 │ 64 │ Time To Live │ Protocol │ Header Checksum │\n"
"├───────┼─────┼───────────────┴─────────────────────┴───────────────────────────────────────────────┤\n"
"│ 12 │ 96 │ Source IP Address │\n"
"├───────┼─────┼─────────────────────────────────────────────────────────────────────────────────────┤\n"
"│ 16 │ 128 │ Destination IP Address │\n"
"├───────┼─────┼─────────────────────────────────────────────────────────────────────────────────────┤\n"
"│ 20 │ 160 │ │\n"
"├───────┼─────┤ │\n"
"│ ... │ ... │ Options │\n"
"├───────┼─────┤ │\n"
"│ 56 │ 448 │ │\n"
"└───────┴─────┴─────────────────────────────────────────────────────────────────────────────────────┘\n"));
}
}
static void
test_missing_cells ()
{
style_manager sm;
table table (table::size_t (3, 3));
table.set_cell (table::coord_t (1, 0), styled_string (sm, "A"));
table.set_cell (table::coord_t (0, 1), styled_string (sm, "B"));
table.set_cell (table::coord_t (1, 1), styled_string (sm, "C"));
table.set_cell (table::coord_t (2, 1), styled_string (sm, "D"));
table.set_cell (table::coord_t (1, 2), styled_string (sm, "E"));
ASSERT_TABLE_NULL_CELL (table, 0, 0);
ASSERT_TABLE_CELL_STREQ (table, 1, 0, "A");
ASSERT_TABLE_NULL_CELL (table, 2, 0);
ASSERT_TABLE_CELL_STREQ (table, 0, 1, "B");
ASSERT_TABLE_CELL_STREQ (table, 1, 1, "C");
ASSERT_TABLE_CELL_STREQ (table, 2, 1, "D");
ASSERT_TABLE_NULL_CELL (table, 0, 2);
ASSERT_TABLE_CELL_STREQ (table, 1, 2, "E");
ASSERT_TABLE_NULL_CELL (table, 2, 2);
{
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
(" +-+\n"
" |A|\n"
"+-+-+-+\n"
"|B|C|D|\n"
"+-+-+-+\n"
" |E|\n"
" +-+\n"));
}
{
canvas canvas (table.to_canvas (unicode_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
(" ┌─┐\n"
" │A│\n"
"┌─┼─┼─┐\n"
"│B│C│D│\n"
"└─┼─┼─┘\n"
" │E│\n"
" └─┘\n"));
}
}
static void
test_add_row ()
{
style_manager sm;
table table (table::size_t (3, 0));
for (int i = 0; i < 5; i++)
{
const int y = table.add_row ();
for (int x = 0; x < 3; x++)
table.set_cell (table::coord_t (x, y),
styled_string::from_fmt (sm, nullptr,
"%i, %i", x, y));
}
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+----+----+----+\n"
"|0, 0|1, 0|2, 0|\n"
"+----+----+----+\n"
"|0, 1|1, 1|2, 1|\n"
"+----+----+----+\n"
"|0, 2|1, 2|2, 2|\n"
"+----+----+----+\n"
"|0, 3|1, 3|2, 3|\n"
"+----+----+----+\n"
"|0, 4|1, 4|2, 4|\n"
"+----+----+----+\n"));
}
static void
test_alignment ()
{
style_manager sm;
table table (table::size_t (9, 9));
table.set_cell_span (table::rect_t (table::coord_t (0, 0),
table::size_t (3, 3)),
styled_string (sm, "left top"),
x_align::LEFT, y_align::TOP);
table.set_cell_span (table::rect_t (table::coord_t (3, 0),
table::size_t (3, 3)),
styled_string (sm, "center top"),
x_align::CENTER, y_align::TOP);
table.set_cell_span (table::rect_t (table::coord_t (6, 0),
table::size_t (3, 3)),
styled_string (sm, "right top"),
x_align::RIGHT, y_align::TOP);
table.set_cell_span (table::rect_t (table::coord_t (0, 3),
table::size_t (3, 3)),
styled_string (sm, "left center"),
x_align::LEFT, y_align::CENTER);
table.set_cell_span (table::rect_t (table::coord_t (3, 3),
table::size_t (3, 3)),
styled_string (sm, "center center"),
x_align::CENTER, y_align::CENTER);
table.set_cell_span (table::rect_t (table::coord_t (6, 3),
table::size_t (3, 3)),
styled_string (sm, "right center"),
x_align::RIGHT, y_align::CENTER);
table.set_cell_span (table::rect_t (table::coord_t (0, 6),
table::size_t (3, 3)),
styled_string (sm, "left bottom"),
x_align::LEFT, y_align::BOTTOM);
table.set_cell_span (table::rect_t (table::coord_t (3, 6),
table::size_t (3, 3)),
styled_string (sm, "center bottom"),
x_align::CENTER, y_align::BOTTOM);
table.set_cell_span (table::rect_t (table::coord_t (6, 6),
table::size_t (3, 3)),
styled_string (sm, "right bottom"),
x_align::RIGHT, y_align::BOTTOM);
canvas canvas (table.to_canvas (ascii_theme(), sm));
ASSERT_CANVAS_STREQ
(canvas, false,
("+-----------+-------------+------------+\n"
"|left top | center top | right top|\n"
"| | | |\n"
"+-----------+-------------+------------+\n"
"|left center|center center|right center|\n"
"| | | |\n"
"+-----------+-------------+------------+\n"
"| | | |\n"
"|left bottom|center bottom|right bottom|\n"
"+-----------+-------------+------------+\n"));
}
/* Run all selftests in this file. */
void
text_art_table_cc_tests ()
{
test_tic_tac_toe ();
test_text_table ();
test_offset_table ();
test_spans ();
test_spans_2 ();
test_spans_3 ();
test_double_width_chars ();
test_ipv4_header ();
test_missing_cells ();
test_add_row ();
test_alignment ();
}
} // namespace selftest
#endif /* #if CHECKING_P */