[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Message-Id: <20220519172421.162394-7-kent.overstreet@gmail.com>
Date: Thu, 19 May 2022 13:23:59 -0400
From: Kent Overstreet <kent.overstreet@...il.com>
To: linux-kernel@...r.kernel.org, linux-mm@...r.kernel.org,
pmladek@...e.com, rostedt@...dmis.org, senozhatsky@...omium.org
Cc: Kent Overstreet <kent.overstreet@...il.com>,
andriy.shevchenko@...ux.intel.com, willy@...radead.org
Subject: [PATCH v2 06/28] lib/printbuf: Tabstops, indenting
This patch adds two new features to printbuf for structured formatting:
- Indent level: the indent level, as a number of spaces, may be
increased with pr_indent_add() and decreased with pr_indent_sub().
Subsequent lines, when started with pr_newline() (not "\n", although
that may change) will then be intended according to the current
indent level. This helps with pretty-printers that structure a large
amonut of data across multiple lines and multiple functions.
- Tabstops: Tabstops may be set by assigning to the printbuf->tabstops
array.
Then, pr_tab() may be used to advance to the next tabstop, printing
as many spaces as required - leaving previous output left justified
to the previous tabstop. pr_tab_rjust() advances to the next tabstop
but inserts the spaces just after the previous tabstop - right
justifying the previously-outputted text to the next tabstop.
Signed-off-by: Kent Overstreet <kent.overstreet@...il.com>
---
include/linux/printbuf.h | 28 +++++++++
lib/printbuf.c | 125 +++++++++++++++++++++++++++++++++++++++
2 files changed, 153 insertions(+)
diff --git a/include/linux/printbuf.h b/include/linux/printbuf.h
index c114072773..798e067457 100644
--- a/include/linux/printbuf.h
+++ b/include/linux/printbuf.h
@@ -36,6 +36,23 @@
* memory allocation failure we usually don't want to bail out and unwind - we
* want to print what we've got, on a best-effort basis. But code that does want
* to return -ENOMEM may check printbuf.allocation_failure.
+ *
+ * Indenting, tabstops:
+ *
+ * To aid is writing multi-line pretty printers spread across multiple
+ * functions, printbufs track the current indent level.
+ *
+ * pr_indent_push() and pr_indent_pop() increase and decrease the current indent
+ * level, respectively.
+ *
+ * To use tabstops, set printbuf->tabstops[]; they are in units of spaces, from
+ * start of line. Once set, pr_tab() will output spaces up to the next tabstop.
+ * pr_tab_rjust() will also advance the current line of text up to the next
+ * tabstop, but it does so by shifting text since the previous tabstop up to the
+ * next tabstop - right justifying it.
+ *
+ * Make sure you use pr_newline() instead of \n in the format string for indent
+ * level and tabstops to work corretly.
*/
#include <linux/string.h>
@@ -44,18 +61,29 @@ struct printbuf {
char *buf;
unsigned size;
unsigned pos;
+ unsigned last_newline;
+ unsigned last_field;
+ unsigned indent;
/*
* If nonzero, allocations will be done with GFP_ATOMIC:
*/
u8 atomic;
bool allocation_failure:1;
bool heap_allocated:1;
+ u8 tabstop;
+ u8 tabstops[4];
};
int printbuf_make_room(struct printbuf *, unsigned);
const char *printbuf_str(const struct printbuf *);
void printbuf_exit(struct printbuf *);
+void pr_newline(struct printbuf *);
+void pr_indent_add(struct printbuf *, unsigned);
+void pr_indent_sub(struct printbuf *, unsigned);
+void pr_tab(struct printbuf *);
+void pr_tab_rjust(struct printbuf *);
+
/* Initializer for a heap allocated printbuf: */
#define PRINTBUF ((struct printbuf) { .heap_allocated = true })
diff --git a/lib/printbuf.c b/lib/printbuf.c
index 0093b34158..c9f730a215 100644
--- a/lib/printbuf.c
+++ b/lib/printbuf.c
@@ -11,6 +11,11 @@
#include <linux/slab.h>
#include <linux/printbuf.h>
+static inline size_t printbuf_linelen(struct printbuf *buf)
+{
+ return buf->pos - buf->last_newline;
+}
+
int printbuf_make_room(struct printbuf *out, unsigned extra)
{
unsigned new_size;
@@ -68,3 +73,123 @@ void printbuf_exit(struct printbuf *buf)
}
}
EXPORT_SYMBOL(printbuf_exit);
+
+void pr_newline(struct printbuf *buf)
+{
+ unsigned i;
+
+ printbuf_make_room(buf, 1 + buf->indent);
+
+ __pr_char(buf, '\n');
+
+ buf->last_newline = buf->pos;
+
+ for (i = 0; i < buf->indent; i++)
+ __pr_char(buf, ' ');
+
+ printbuf_nul_terminate(buf);
+
+ buf->last_field = buf->pos;
+ buf->tabstop = 0;
+}
+EXPORT_SYMBOL(pr_newline);
+
+/**
+ * pr_indent_add - add to the current indent level
+ *
+ * @buf: printbuf to control
+ * @spaces: number of spaces to add to the current indent level
+ *
+ * Subsequent lines, and the current line if the output position is at the start
+ * of the current line, will be indented by @spaces more spaces.
+ */
+void pr_indent_add(struct printbuf *buf, unsigned spaces)
+{
+ if (WARN_ON_ONCE(buf->indent + spaces < buf->indent))
+ spaces = 0;
+
+ buf->indent += spaces;
+ while (spaces--)
+ pr_char(buf, ' ');
+}
+EXPORT_SYMBOL(pr_indent_add);
+
+/**
+ * pr_indent_sub - subtract from the current indent level
+ *
+ * @buf: printbuf to control
+ * @spaces: number of spaces to subtract from the current indent level
+ *
+ * Subsequent lines, and the current line if the output position is at the start
+ * of the current line, will be indented by @spaces less spaces.
+ */
+void pr_indent_sub(struct printbuf *buf, unsigned spaces)
+{
+ if (WARN_ON_ONCE(spaces > buf->indent))
+ spaces = buf->indent;
+
+ if (buf->last_newline + buf->indent == buf->pos) {
+ buf->pos -= spaces;
+ printbuf_nul_terminate(buf);
+ }
+ buf->indent -= spaces;
+}
+EXPORT_SYMBOL(pr_indent_sub);
+
+/**
+ * pr_tab - Advance printbuf to the next tabstop
+ *
+ * @buf: printbuf to control
+ *
+ * Advance output to the next tabstop by printing spaces.
+ */
+void pr_tab(struct printbuf *out)
+{
+ int spaces = max(0, out->tabstops[out->tabstop] - printbuf_linelen(out));
+
+ BUG_ON(out->tabstop > ARRAY_SIZE(out->tabstops));
+
+ pr_chars(out, ' ', spaces);
+
+ out->last_field = out->pos;
+ out->tabstop++;
+}
+EXPORT_SYMBOL(pr_tab);
+
+/**
+ * pr_tab - Advance printbuf to the next tabstop, right justifying previous
+ * output
+ *
+ * @buf: printbuf to control
+ *
+ * Advance output to the next tabstop by inserting spaces immediately after the
+ * previous tabstop, right justifying previously outputted text.
+ */
+void pr_tab_rjust(struct printbuf *buf)
+{
+ BUG_ON(buf->tabstop > ARRAY_SIZE(buf->tabstops));
+
+ if (printbuf_linelen(buf) < buf->tabstops[buf->tabstop]) {
+ unsigned move = buf->pos - buf->last_field;
+ unsigned shift = buf->tabstops[buf->tabstop] -
+ printbuf_linelen(buf);
+
+ printbuf_make_room(buf, shift);
+
+ if (buf->last_field + shift < buf->size)
+ memmove(buf->buf + buf->last_field + shift,
+ buf->buf + buf->last_field,
+ min(move, buf->size - 1 - buf->last_field - shift));
+
+ if (buf->last_field < buf->size)
+ memset(buf->buf + buf->last_field, ' ',
+ min(shift, buf->size - buf->last_field));
+
+ buf->pos += shift;
+ printbuf_nul_terminate(buf);
+ }
+
+ buf->last_field = buf->pos;
+ buf->tabstop++;
+}
+EXPORT_SYMBOL(pr_tab_rjust);
--
2.36.0
Powered by blists - more mailing lists