/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Copyright 2020 Tintri by DDN, Inc. All rights reserved.
 */

#include "ndrgen.h"
#include "y.tab.h"


static void print_declaration(ndr_node_t *);
static void print_advice_list(ndr_node_t *);
static void print_node_list(ndr_node_t *);


void
tdata_dump(void)
{
        print_node_list(construct_list);
}

void
print_node(ndr_node_t *np)
{
        char            *nm;

        if (!np) {
                (void) printf("<null>");
                return;
        }

        switch (np->label) {
        case ALIGN_KW:          nm = "align";           break;
        case FAKE_KW:           nm = "fake";            break;
        case STRUCT_KW:         nm = "struct";          break;
        case UNION_KW:          nm = "union";           break;
        case TYPEDEF_KW:        nm = "typedef";         break;
        case INTERFACE_KW:      nm = "interface";       break;
        case IN_KW:             nm = "in";              break;
        case OUT_KW:            nm = "out";             break;
        case SIZE_IS_KW:        nm = "size_is";         break;
        case LENGTH_IS_KW:      nm = "length_is";       break;
        case STRING_KW:         nm = "string";          break;
        case TRANSMIT_AS_KW:    nm = "transmit_as";     break;
        case OPERATION_KW:      nm = "operation";       break;
        case UUID_KW:           nm = "uuid";            break;
        case _NO_REORDER_KW:    nm = "_no_reorder";     break;
        case EXTERN_KW:         nm = "extern";          break;
        case ARG_IS_KW:         nm = "arg_is";          break;
        case CASE_KW:           nm = "case";            break;
        case DEFAULT_KW:        nm = "default";         break;
        case BASIC_TYPE:        nm = "<btype>";         break;
        case TYPENAME:          nm = "<tname>";         break;
        case IDENTIFIER:        nm = "<ident>";         break;
        case INTEGER:           nm = "<intg>";          break;
        case STRING:            nm = "<string>";        break;
        case STAR:              nm = "<*>";             break;
        case LB:                nm = "<[>";             break;
        case LP:                nm = "<(>";             break;
        case L_MEMBER:          nm = "<member>";        break;
        default:
                (void) printf("<<lab=%d>>", np->label);
                return;
        }

        switch (np->label) {
        case STRUCT_KW:
        case UNION_KW:
        case TYPEDEF_KW:
                (void) printf("\n");
                if (np->n_c_advice) {
                        print_advice_list(np->n_c_advice);
                        (void) printf("\n");
                }
                (void) printf("%s ", nm);
                print_node(np->n_c_typename);
                (void) printf(" {\n");
                print_node_list(np->n_c_members);
                (void) printf("};\n");
                break;

        case IN_KW:
        case OUT_KW:
        case STRING_KW:
        case DEFAULT_KW:
        case _NO_REORDER_KW:
        case EXTERN_KW:
        case FAKE_KW:
                (void) printf("%s", nm);
                break;

        case ALIGN_KW:
                /*
                 * Don't output anything for default alignment.
                 */
                if ((np->n_a_arg == NULL) || (np->n_a_arg->n_int == 0))
                        break;
                (void) printf("%s(", nm);
                print_node(np->n_a_arg);
                (void) printf(")");
                break;

        case SIZE_IS_KW:
        case LENGTH_IS_KW:
                (void) printf("%s(", nm);
                print_field_attr(np);
                (void) printf(")");
                break;

        case INTERFACE_KW:
        case TRANSMIT_AS_KW:
        case ARG_IS_KW:
        case CASE_KW:
        case OPERATION_KW:
        case UUID_KW:
                (void) printf("%s(", nm);
                print_node(np->n_a_arg);
                (void) printf(")");
                break;

        case BASIC_TYPE:
        case TYPENAME:
        case IDENTIFIER:
                (void) printf("%s", np->n_sym->name);
                break;

        case INTEGER:
                (void) printf("%ld", np->n_int);
                break;

        case STRING:
                (void) printf("\"%s\"", np->n_str);
                break;

        case STAR:
                (void) printf("*");
                print_node(np->n_d_descend);
                break;

        case LB:
                print_node(np->n_d_descend);
                (void) printf("[");
                if (np->n_d_dim)
                        print_node(np->n_d_dim);
                (void) printf("]");
                break;

        case LP:
                (void) printf("(");
                print_node(np->n_d_descend);
                (void) printf(")");
                break;

        case L_MEMBER:
                if (np->n_m_advice) {
                        (void) printf("    ");
                        print_advice_list(np->n_m_advice);
                        (void) printf("\n");
                }
                (void) printf("\t");
                print_declaration(np);
                (void) printf(";\n");
                break;

        default:
                return;
        }
}

/*
 * Field attributes are used to specify the size of an array, or the portion
 * of the array, that contains valid data, which is done by associating
 * another parameter with the array that contains the sizing information.
 *
 * Supports formats such as size_is(x) or size_is(x / 2).  The supported
 * operators are:
 *
 *      * / % + - & | ^
 */
void
print_field_attr(ndr_node_t *np)
{
        static char     *valid = "*/%+-&|^";
        ndr_node_t      *arg;
        char            *name;
        char            *operator;
        long            value;

        arg = np->n_a_arg;
        if (arg->label != IDENTIFIER)
                fatal_error("invalid label %d", arg->label);
        if ((name = arg->n_sym->name) == NULL)
                fatal_error("missing symbol name");

        arg = np->n_a_arg1;
        operator = NULL;
        if (arg->label == IDENTIFIER) {
                operator = arg->n_sym->name;

                if (operator != NULL) {
                        /*
                         * The lexer sets the name and operator to
                         * the same value if there is no operator.
                         */
                        if (strcmp(name, operator) == 0)
                                operator = NULL;
                        else if (strchr(valid, *operator) == NULL)
                                compile_error("invalid operator: %s", operator);
                }
        }

        arg = np->n_a_arg2;
        if (arg->label == INTEGER) {
                value = arg->n_int;

                if ((value == 0) && strcmp(operator, "/") == 0)
                        compile_error("divide by zero");
        }

        if (operator)
                (void) printf("%s %s %ldUL", name, operator, value);
        else
                (void) printf("%s", name);
}

static void
print_declaration(ndr_node_t *np)
{
        ndr_node_t      *dnp = np->n_m_decl;
        char            buf[NDLBUFSZ];
        char            *p = buf;

        if (np->n_m_type &&
            (np->n_m_type->label == IDENTIFIER ||
            np->n_m_type->label == TYPENAME)) {
                (void) snprintf(buf, NDLBUFSZ, "%s", np->n_m_type->n_sym->name);

                while (*p)
                        p++;

                if (dnp && dnp->label == STAR) {
                        *p++ = ' ';
                        while (dnp && dnp->label == STAR) {
                                *p++ = '*';
                                dnp = dnp->n_d_descend;
                        }
                }
                *p = 0;
                (void) printf("%-23s ", buf);
        } else {
                print_node(np->n_m_type);
                (void) printf(" ");
        }

        print_node(dnp);
}

static void
print_advice_list(ndr_node_t *np)
{
        if (!np)
                return;

        (void) printf("[");
        for (; np; np = np->n_next) {
                print_node(np);
                if (np->n_next)
                        (void) printf(" ");
        }
        (void) printf("]");
}

static void
print_node_list(ndr_node_t *np)
{
        for (; np; np = np->n_next) {
                print_node(np);
        }
}