xref: /src/usr.bin/xlint/common/tyname.c

/*	$NetBSD: tyname.c,v 1.67 2025/09/14 11:14:00 rillig Exp $	*/

/*-
 * Copyright (c) 2005 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Christos Zoulas.
 *
 * 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.
 */

#if HAVE_NBTOOL_CONFIG_H
#include "nbtool_config.h"
#endif

#include <sys/cdefs.h>
#if defined(__RCSID)
__RCSID("$NetBSD: tyname.c,v 1.67 2025/09/14 11:14:00 rillig Exp $");
#endif

#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>

#if IS_LINT1
#include "lint1.h"
#else
#include "lint2.h"
#endif

/* A tree of strings. */
typedef struct name_tree_node {
	const char *ntn_name;
	struct name_tree_node *ntn_less;
	struct name_tree_node *ntn_greater;
} name_tree_node;

static name_tree_node *type_names;

static name_tree_node *
new_name_tree_node(const char *name)
{
	name_tree_node *n;

	n = xmalloc(sizeof(*n));
	n->ntn_name = xstrdup(name);
	n->ntn_less = NULL;
	n->ntn_greater = NULL;
	return n;
}

/* Return the canonical instance of the string, with unlimited lifetime. */
static const char *
intern(const char *name)
{
	name_tree_node *n = type_names, **next;
	int cmp;

	if (n == NULL) {
		n = new_name_tree_node(name);
		type_names = n;
		return n->ntn_name;
	}

	while ((cmp = strcmp(name, n->ntn_name)) != 0) {
		next = cmp < 0 ? &n->ntn_less : &n->ntn_greater;
		if (*next == NULL) {
			*next = new_name_tree_node(name);
			return (*next)->ntn_name;
		}
		n = *next;
	}
	return n->ntn_name;
}

#if !IS_LINT1
static
#endif
void
buf_init(buffer *buf)
{
	buf->len = 0;
	buf->cap = 128;
	buf->data = xmalloc(buf->cap);
	buf->data[0] = '\0';
}

static void
buf_done(buffer *buf)
{
	free(buf->data);
}

static void
buf_add_mem(buffer *buf, const char *s, size_t n)
{
	while (buf->len + n + 1 >= buf->cap) {
		buf->cap *= 2;
		buf->data = xrealloc(buf->data, buf->cap);
	}

	memcpy(buf->data + buf->len, s, n);
	buf->len += n;
	buf->data[buf->len] = '\0';
}

#if IS_LINT1
void
buf_add_char(buffer *buf, char c)
{
	buf_add_mem(buf, &c, 1);
}
#endif

#if !IS_LINT1
static
#endif
void
buf_add(buffer *buf, const char *s)
{
	buf_add_mem(buf, s, strlen(s));
}

static void
buf_add_int(buffer *buf, int n)
{
	char num[1 + sizeof(n) * CHAR_BIT + 1];

	(void)snprintf(num, sizeof(num), "%d", n);
	buf_add(buf, num);
}

const char *
tspec_name(tspec_t t)
{
	const char *name = ttab[t].tt_name;
	assert(name != NULL);
	return name;
}

static void
type_name_of_function(buffer *buf, const type_t *tp)
{
	const char *sep = "";

	buf_add(buf, "(");
	if (tp->t_proto) {
#if IS_LINT1
		const sym_t *param = tp->u.params;
		if (param == NULL)
			buf_add(buf, "void");
		for (; param != NULL; param = param->s_next) {
			buf_add(buf, sep), sep = ", ";
			buf_add(buf, type_name(param->s_type));
		}
#else
		const type_t **argtype;

		argtype = tp->t_args;
		if (*argtype == NULL)
			buf_add(buf, "void");
		for (; *argtype != NULL; argtype++) {
			buf_add(buf, sep), sep = ", ";
			buf_add(buf, type_name(*argtype));
		}
#endif
	}
	if (tp->t_vararg) {
		buf_add(buf, sep);
		buf_add(buf, "...");
	}
	buf_add(buf, ") returning ");
	buf_add(buf, type_name(tp->t_subt));
}

static void
type_name_of_struct_or_union(buffer *buf, const type_t *tp)
{
	buf_add(buf, " ");
#if IS_LINT1
	if (tp->u.sou->sou_tag->s_name == unnamed &&
	    tp->u.sou->sou_first_typedef != NULL) {
		buf_add(buf, "typedef ");
		buf_add(buf, tp->u.sou->sou_first_typedef->s_name);
	} else {
		buf_add(buf, tp->u.sou->sou_tag->s_name);
	}
#else
	buf_add(buf, tp->t_isuniqpos ? "*anonymous*" : tp->t_tag->h_name);
#endif
}

static void
type_name_of_enum(buffer *buf, const type_t *tp)
{
	buf_add(buf, " ");
#if IS_LINT1
	if (tp->u.enumer->en_tag->s_name == unnamed &&
	    tp->u.enumer->en_first_typedef != NULL) {
		buf_add(buf, "typedef ");
		buf_add(buf, tp->u.enumer->en_first_typedef->s_name);
	} else {
		buf_add(buf, tp->u.enumer->en_tag->s_name);
	}
#else
	buf_add(buf, tp->t_isuniqpos ? "*anonymous*" : tp->t_tag->h_name);
#endif
}

static void
type_name_of_array(buffer *buf, const type_t *tp)
{
	buf_add(buf, "[");
#if IS_LINT1
	if (tp->t_incomplete_array)
		buf_add(buf, "unknown_size");
	else
		buf_add_int(buf, tp->u.dimension);
#else
	buf_add_int(buf, tp->t_dim);
#endif
	buf_add(buf, "]");
	buf_add(buf, " of ");
	buf_add(buf, type_name(tp->t_subt));
}

const char *
type_name(const type_t *tp)
{
	tspec_t t;
	buffer buf;
	const char *name;

	if (tp == NULL)
		return "(null)";

	if ((t = tp->t_tspec) == INT && tp->t_is_enum)
		t = ENUM;

	buf_init(&buf);
	if (tp->t_const)
		buf_add(&buf, "const ");
	if (tp->t_volatile)
		buf_add(&buf, "volatile ");
#if IS_LINT1
	if (tp->t_noreturn)
		buf_add(&buf, "noreturn ");
#endif

#if IS_LINT1
	if (is_struct_or_union(t) && tp->u.sou->sou_incomplete)
		buf_add(&buf, "incomplete ");
#endif
	buf_add(&buf, tspec_name(t));

#if IS_LINT1
	if (tp->t_bitfield) {
		buf_add(&buf, ":");
		buf_add_int(&buf, (int)tp->t_bit_field_width);
	}
#endif

	switch (t) {
	case PTR:
		buf_add(&buf, " to ");
		buf_add(&buf, type_name(tp->t_subt));
		break;
	case ENUM:
		type_name_of_enum(&buf, tp);
		break;
	case STRUCT:
	case UNION:
		type_name_of_struct_or_union(&buf, tp);
		break;
	case ARRAY:
		type_name_of_array(&buf, tp);
		break;
	case FUNC:
		type_name_of_function(&buf, tp);
		break;
	default:
		break;
	}

	name = intern(buf.data);
	buf_done(&buf);
	return name;
}

#if IS_LINT1
const char *
expr_type_name(const tnode_t *tn)
{
	const char *tp_name = type_name(tn->tn_type);
	const char *otp_name = type_name(before_conversion(tn)->tn_type);
	if (tp_name == otp_name)
		return tp_name;
	buffer buf;
	buf_init(&buf);
	buf_add(&buf, tp_name);
	buf_add(&buf, " promoted from ");
	buf_add(&buf, otp_name);
	const char *name = intern(buf.data);
	buf_done(&buf);
	return name;
}
#endif