/*      $NetBSD: debug.c,v 1.74 2025/01/04 21:20:59 rillig Exp $        */

/*-
* Copyright (c) 2023 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Roland Illig <[email protected]>.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__RCSID("$NetBSD: debug.c,v 1.74 2025/01/04 21:20:59 rillig Exp $");

#include <stdarg.h>
#include <string.h>

#include "indent.h"

#ifdef debug

static struct {
       // false        show only the changes to the parser state
       // true         show unchanged parts of the parser state as well
       bool full_parser_state;
} config = {
       .full_parser_state = false,
};

const char *const lsym_name[] = {
       "lsym_eof",
       "lsym_preprocessing",
       "lsym_newline",
       "lsym_comment",
       "lsym_lparen",
       "lsym_rparen",
       "lsym_lbracket",
       "lsym_rbracket",
       "lsym_lbrace",
       "lsym_rbrace",
       "lsym_period",
       "lsym_unary_op",
       "lsym_sizeof",
       "lsym_offsetof",
       "lsym_postfix_op",
       "lsym_binary_op",
       "lsym_question",
       "lsym_question_colon",
       "lsym_comma",
       "lsym_typedef",
       "lsym_modifier",
       "lsym_tag",
       "lsym_type",
       "lsym_word",
       "lsym_funcname",
       "lsym_label_colon",
       "lsym_other_colon",
       "lsym_semicolon",
       "lsym_case",
       "lsym_default",
       "lsym_do",
       "lsym_else",
       "lsym_for",
       "lsym_if",
       "lsym_switch",
       "lsym_while",
       "lsym_return",
};

const char *const psym_name[] = {
       "psym_0",
       "psym_lbrace_block",
       "psym_lbrace_struct",
       "psym_lbrace_union",
       "psym_lbrace_enum",
       "psym_rbrace",
       "psym_decl",
       "psym_stmt",
       "psym_for_exprs",
       "psym_if_expr",
       "psym_if_expr_stmt",
       "psym_if_expr_stmt_else",
       "psym_else",
       "psym_switch_expr",
       "psym_do",
       "psym_do_stmt",
       "psym_while_expr",
};

static const char *const newline_name[] = {
       "nl_no",
       "nl_unless_if",
       "nl_unless_lbrace",
       "nl_unless_semicolon",
       "nl_yes",
};

static const char *const declaration_name[] = {
       "decl_no",
       "decl_begin",
       "decl_end",
};

static const char *const badp_name[] = {
       "badp_none",
       "badp_seen_lbrace",
       "badp_decl",
       "badp_seen_decl",
       "badp_yes",
};

const char *const paren_level_cast_name[] = {
       "cast_unknown",
       "cast_maybe",
       "cast_no",
};

const char *const line_kind_name[] = {
       "lk_other",
       "lk_blank",
       "lk_pre_if",
       "lk_pre_endif",
       "lk_pre_other",
       "lk_stmt_head",
       "lk_func_end",
       "lk_block_comment",
       "lk_case_or_default",
};

static const char *const extra_expr_indent_name[] = {
       "eei_no",
       "eei_maybe",
       "eei_last"
};

static struct {
       struct parser_state prev_ps;
       bool ps_first;
       const char *heading1;
       const char *heading2;
       unsigned wrote_newlines;
} state = {
       .ps_first = true,
       .wrote_newlines = 1,
};

static FILE *
debug_file(void)
{
       return output == stdout ? stderr : stdout;
}

static void
debug_print_headings(void)
{
       if (state.heading1 != NULL) {
               (void)fprintf(debug_file(), "%s:\n", state.heading1);
               state.heading1 = NULL;
               state.wrote_newlines = 1;
       }
       if (state.heading2 != NULL) {
               (void)fprintf(debug_file(), "\t%s:\n", state.heading2);
               state.heading2 = NULL;
               state.wrote_newlines = 1;
       }
}

void
debug_printf(const char *fmt, ...)
{
       va_list ap;

       debug_print_headings();
       va_start(ap, fmt);
       (void)vfprintf(debug_file(), fmt, ap);
       va_end(ap);
       state.wrote_newlines = 0;
}

void
debug_println(const char *fmt, ...)
{
       va_list ap;

       debug_print_headings();
       va_start(ap, fmt);
       (void)vfprintf(debug_file(), fmt, ap);
       va_end(ap);
       (void)fprintf(debug_file(), "\n");
       state.wrote_newlines = fmt[0] == '\0' ? state.wrote_newlines + 1 : 1;
}

void
debug_blank_line(void)
{
       while (state.wrote_newlines < 2)
               debug_println("");
}

void
debug_vis_range(const char *s, size_t len)
{
       debug_printf("\"");
       for (size_t i = 0; i < len; i++) {
               const char *p = s + i;
               if (*p == '\\' || *p == '"')
                       debug_printf("\\%c", *p);
               else if (isprint((unsigned char)*p))
                       debug_printf("%c", *p);
               else if (*p == '\n')
                       debug_printf("\\n");
               else if (*p == '\t')
                       debug_printf("\\t");
               else
                       debug_printf("\\x%02x", (unsigned char)*p);
       }
       debug_printf("\"");
}

void
debug_print_buf(const char *name, const struct buffer *buf)
{
       if (buf->len > 0) {
               debug_printf(" %s ", name);
               debug_vis_range(buf->s, buf->len);
       }
}

void
debug_buffers(const char *descr)
{
       if (lab.len > 0 || code.len > 0 || com.len > 0) {
               debug_printf("%s:", descr);
               debug_print_buf("label", &lab);
               debug_print_buf("code", &code);
               debug_print_buf("comment", &com);
               debug_blank_line();
       }
}

static void
debug_ps_bool_member(const char *name, bool prev, bool curr)
{
       if (!state.ps_first && curr != prev) {
               char diff = " -+x"[(prev ? 1 : 0) + (curr ? 2 : 0)];
               debug_println("\t\t%s: [%c]", name, diff);
       } else if (config.full_parser_state || state.ps_first)
               debug_println("\t\t%s: [%c]", name, curr ? 'x' : ' ');
}

static void
debug_ps_int_member(const char *name, int prev, int curr)
{
       if (!state.ps_first && curr != prev)
               debug_println("\t\t%s: %d -> %d", name, prev, curr);
       else if (config.full_parser_state || state.ps_first)
               debug_println("\t\t%s: %d", name, curr);
}

static void
debug_ps_enum_member(const char *name, const char *prev, const char *curr)
{
       if (!state.ps_first && strcmp(prev, curr) != 0)
               debug_println("\t\t%s: %s -> %s", name, prev, curr);
       else if (config.full_parser_state || state.ps_first)
               debug_println("\t\t%s: %s", name, curr);
}

static void
debug_ps_str_member(const char *name,
   void (*to_string)(struct buffer *, const struct parser_state *))
{
       static struct buffer prev_buf;
       static struct buffer curr_buf;

       buf_clear(&prev_buf);
       to_string(&prev_buf, &state.prev_ps);
       buf_clear(&curr_buf);
       to_string(&curr_buf, &ps);

       if (!state.ps_first && strcmp(prev_buf.s, curr_buf.s) != 0)
               debug_println("\t\t%s: %s -> %s",
                   name, prev_buf.s, curr_buf.s);
       else if (config.full_parser_state || state.ps_first)
               debug_println("\t\t%s: %s", name, curr_buf.s);
}

static void
ps_di_stack_to_string(struct buffer *buf, const struct parser_state *s)
{
       for (int i = 0; i < s->decl_level; i++) {
               char str[64];
               snprintf(str, sizeof(str), "%s%d",
                        i > 0 ? " " : "", s->di_stack[i]);
               buf_add_str(buf, str);
       }
       if (s->decl_level == 0)
               buf_add_str(buf, "none");
}

static void
ps_paren_to_string(struct buffer *buf, const struct parser_state *s)
{
       for (size_t i = 0; i < s->paren.len; i++) {
               buf_add_str(buf, i > 0 ? "  " : "");
               buf_add_str(buf, paren_level_cast_name[s->paren.item[i].cast]);
               char str[64];
               snprintf(str, sizeof(str), " %d", s->paren.item[i].indent);
               buf_add_str(buf, str);
       }
       if (s->paren.len == 0)
               buf_add_str(buf, "none");
}

void
ps_psyms_to_string(struct buffer *buf, const struct parser_state *s)
{
       for (size_t i = 0; i < s->psyms.len; i++) {
               char num[64];
               snprintf(num, sizeof(num), "%s%d ",
                   i > 0 ? "  " : "", s->psyms.ind_level[i]);
               buf_add_str(buf, num);
               buf_add_str(buf, psym_name[s->psyms.sym[i]]);
       }
}

#define debug_ps_bool(name) \
       debug_ps_bool_member(#name, state.prev_ps.name, ps.name)
#define debug_ps_int(name) \
       debug_ps_int_member(#name, state.prev_ps.name, ps.name)
#define debug_ps_enum(name, names) \
       debug_ps_enum_member(#name, (names)[state.prev_ps.name], \
           (names)[ps.name])
#define debug_ps_str(name, to_string) \
       debug_ps_str_member((/* LINTED 129 */(void)&ps.name, #name), to_string)

void
debug_parser_state(void)
{
       debug_blank_line();

       state.heading1 = "parser state";
       state.heading2 = "token classification";
       debug_ps_enum(prev_lsym, lsym_name);
       debug_ps_bool(in_stmt_or_decl);
       debug_ps_bool(in_decl);
       debug_ps_bool(in_typedef_decl);
       debug_ps_bool(in_var_decl);
       debug_ps_bool(in_init);
       debug_ps_int(init_level);
       debug_ps_bool(line_has_func_def);
       debug_ps_bool(in_func_def_params);
       debug_ps_bool(line_has_decl);
       debug_ps_enum(lbrace_kind, psym_name);
       debug_ps_enum(spaced_expr_psym, psym_name);
       debug_ps_bool(seen_case);
       debug_ps_bool(prev_paren_was_cast);
       debug_ps_int(quest_level);

       state.heading2 = "indentation of statements and declarations";
       debug_ps_int(ind_level);
       debug_ps_int(ind_level_follow);
       debug_ps_str(psyms, ps_psyms_to_string);
       debug_ps_bool(line_is_stmt_cont);
       debug_ps_int(decl_level);
       debug_ps_str(di_stack, ps_di_stack_to_string);
       debug_ps_bool(decl_indent_done);
       debug_ps_int(decl_ind);
       debug_ps_bool(tabs_to_var);
       debug_ps_enum(extra_expr_indent, extra_expr_indent_name);

       state.heading2 = "spacing inside a statement or declaration";
       debug_ps_bool(next_unary);
       debug_ps_bool(want_blank);
       debug_ps_int(ind_paren_level);
       debug_ps_str(paren, ps_paren_to_string);

       state.heading2 = "indentation of comments";
       debug_ps_int(comment_ind);
       debug_ps_int(comment_shift);
       debug_ps_bool(comment_cont);

       state.heading2 = "vertical spacing";
       debug_ps_bool(break_after_comma);
       debug_ps_enum(newline, newline_name);
       debug_ps_enum(declaration, declaration_name);
       debug_ps_bool(blank_line_after_decl);
       debug_ps_enum(badp, badp_name);

       state.heading1 = NULL;
       state.heading2 = NULL;
       debug_blank_line();

       parser_state_free(&state.prev_ps);
       parser_state_back_up(&state.prev_ps);
       state.ps_first = false;
}
#endif

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.