cddl/contrib/opensolaris/common/ctf/ctf_decl.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 /*
  30  * CTF Declaration Stack
  31  *
  32  * In order to implement ctf_type_name(), we must convert a type graph back
  33  * into a C type declaration.  Unfortunately, a type graph represents a storage
  34  * class ordering of the type whereas a type declaration must obey the C rules
  35  * for operator precedence, and the two orderings are frequently in conflict.
  36  * For example, consider these CTF type graphs and their C declarations:
  37  *
  38  * CTF_K_POINTER -> CTF_K_FUNCTION -> CTF_K_INTEGER  : int (*)()
  39  * CTF_K_POINTER -> CTF_K_ARRAY -> CTF_K_INTEGER     : int (*)[]
  40  *
  41  * In each case, parentheses are used to raise operator * to higher lexical
  42  * precedence, so the string form of the C declaration cannot be constructed by
  43  * walking the type graph links and forming the string from left to right.
  44  *
  45  * The functions in this file build a set of stacks from the type graph nodes
  46  * corresponding to the C operator precedence levels in the appropriate order.
  47  * The code in ctf_type_name() can then iterate over the levels and nodes in
  48  * lexical precedence order and construct the final C declaration string.
  49  */
  50
  51 #include <ctf_impl.h>
  52
  53 void
  54 ctf_decl_init(ctf_decl_t *cd, char *buf, size_t len)
  55 {
  56         int i;
  57
  58         bzero(cd, sizeof (ctf_decl_t));
  59
  60         for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++)
  61                 cd->cd_order[i] = CTF_PREC_BASE - 1;
  62
  63         cd->cd_qualp = CTF_PREC_BASE;
  64         cd->cd_ordp = CTF_PREC_BASE;
  65
  66         cd->cd_buf = buf;
  67         cd->cd_ptr = buf;
  68         cd->cd_end = buf + len;
  69 }
  70
  71 void
  72 ctf_decl_fini(ctf_decl_t *cd)
  73 {
  74         ctf_decl_node_t *cdp, *ndp;
  75         int i;
  76
  77         for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++) {
  78                 for (cdp = ctf_list_next(&cd->cd_nodes[i]);
  79                     cdp != NULL; cdp = ndp) {
  80                         ndp = ctf_list_next(cdp);
  81                         ctf_free(cdp, sizeof (ctf_decl_node_t));
  82                 }
  83         }
  84 }
  85
  86 void
  87 ctf_decl_push(ctf_decl_t *cd, ctf_file_t *fp, ctf_id_t type)
  88 {
  89         ctf_decl_node_t *cdp;
  90         ctf_decl_prec_t prec;
  91         uint_t kind, n = 1;
  92         int is_qual = 0;
  93
  94         const ctf_type_t *tp;
  95         ctf_arinfo_t ar;
  96
  97         if ((tp = ctf_lookup_by_id(&fp, type)) == NULL) {
  98                 cd->cd_err = fp->ctf_errno;
  99                 return;
 100         }
 101
 102         switch (kind = LCTF_INFO_KIND(fp, tp->ctt_info)) {
 103         case CTF_K_ARRAY:
 104                 (void) ctf_array_info(fp, type, &ar);
 105                 ctf_decl_push(cd, fp, ar.ctr_contents);
 106                 n = ar.ctr_nelems;
 107                 prec = CTF_PREC_ARRAY;
 108                 break;
 109
 110         case CTF_K_TYPEDEF:
 111                 if (ctf_strptr(fp, tp->ctt_name)[0] == '\0') {
 112                         ctf_decl_push(cd, fp, tp->ctt_type);
 113                         return;
 114                 }
 115                 prec = CTF_PREC_BASE;
 116                 break;
 117
 118         case CTF_K_FUNCTION:
 119                 ctf_decl_push(cd, fp, tp->ctt_type);
 120                 prec = CTF_PREC_FUNCTION;
 121                 break;
 122
 123         case CTF_K_POINTER:
 124                 ctf_decl_push(cd, fp, tp->ctt_type);
 125                 prec = CTF_PREC_POINTER;
 126                 break;
 127
 128         case CTF_K_VOLATILE:
 129         case CTF_K_CONST:
 130         case CTF_K_RESTRICT:
 131                 ctf_decl_push(cd, fp, tp->ctt_type);
 132                 prec = cd->cd_qualp;
 133                 is_qual++;
 134                 break;
 135
 136         default:
 137                 prec = CTF_PREC_BASE;
 138         }
 139
 140         if ((cdp = ctf_alloc(sizeof (ctf_decl_node_t))) == NULL) {
 141                 cd->cd_err = EAGAIN;
 142                 return;
 143         }
 144
 145         cdp->cd_type = type;
 146         cdp->cd_kind = kind;
 147         cdp->cd_n = n;
 148
 149         if (ctf_list_next(&cd->cd_nodes[prec]) == NULL)
 150                 cd->cd_order[prec] = cd->cd_ordp++;
 151
 152         /*
 153          * Reset cd_qualp to the highest precedence level that we've seen so
 154          * far that can be qualified (CTF_PREC_BASE or CTF_PREC_POINTER).
 155          */
 156         if (prec > cd->cd_qualp && prec < CTF_PREC_ARRAY)
 157                 cd->cd_qualp = prec;
 158
 159         /*
 160          * C array declarators are ordered inside out so prepend them.  Also by
 161          * convention qualifiers of base types precede the type specifier (e.g.
 162          * const int vs. int const) even though the two forms are equivalent.
 163          */
 164         if (kind == CTF_K_ARRAY || (is_qual && prec == CTF_PREC_BASE))
 165                 ctf_list_prepend(&cd->cd_nodes[prec], cdp);
 166         else
 167                 ctf_list_append(&cd->cd_nodes[prec], cdp);
 168 }
 169
 170 /*PRINTFLIKE2*/
 171 void
 172 ctf_decl_sprintf(ctf_decl_t *cd, const char *format, ...)
 173 {
 174         size_t len = (size_t)(cd->cd_end - cd->cd_ptr);
 175         va_list ap;
 176         size_t n;
 177
 178         va_start(ap, format);
 179         n = vsnprintf(cd->cd_ptr, len, format, ap);
 180         va_end(ap);
 181
 182         cd->cd_ptr += MIN(n, len);
 183         cd->cd_len += n;
 184 }