lib/dns/gen.c

	gen.c revision 7ec579cd5d07228c0d6cece58b80694ad8d59de9
/*
 * Copyright (C) 1998, 1999, 2000  Internet Software Consortium.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS
 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE
 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
 * SOFTWARE.
 */

/* $Id: gen.c,v 1.34 2000/04/14 20:13:43 explorer Exp $ */

#include <config.h>

#include <sys/types.h>

#include <ctype.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

#ifdef WIN32
#include "gen-win32.h"
#else
#include "gen-unix.h"
#endif

#define FROMTEXTDECL "dns_rdataclass_t rdclass, dns_rdatatype_t type, isc_lex_t *lexer, dns_name_t *origin, isc_boolean_t downcase, isc_buffer_t *target"
#define FROMTEXTARGS "rdclass, type, lexer, origin, downcase, target"
#define FROMTEXTCLASS "rdclass"
#define FROMTEXTTYPE "type"
#define FROMTEXTDEF "use_default = ISC_TRUE"

#define TOTEXTDECL "dns_rdata_t *rdata, dns_rdata_textctx_t *tctx, isc_buffer_t *target"
#define TOTEXTARGS "rdata, tctx, target"
#define TOTEXTCLASS "rdata->rdclass"
#define TOTEXTTYPE "rdata->type"
#define TOTEXTDEF "use_default = ISC_TRUE"

#define FROMWIREDECL "dns_rdataclass_t rdclass, dns_rdatatype_t type, isc_buffer_t *source, dns_decompress_t *dctx, isc_boolean_t downcase, isc_buffer_t *target"
#define FROMWIREARGS "rdclass, type, source, dctx, downcase, target"
#define FROMWIRECLASS "rdclass"
#define FROMWIRETYPE "type"
#define FROMWIREDEF "use_default = ISC_TRUE"

#define TOWIREDECL "dns_rdata_t *rdata, dns_compress_t *cctx, isc_buffer_t *target"
#define TOWIREARGS "rdata, cctx, target"
#define TOWIRECLASS "rdata->rdclass"
#define TOWIRETYPE "rdata->type"
#define TOWIREDEF "use_default = ISC_TRUE"

#define FROMSTRUCTDECL "dns_rdataclass_t rdclass, dns_rdatatype_t type, void *source, isc_buffer_t *target"
#define FROMSTRUCTARGS "rdclass, type, source, target"
#define FROMSTRUCTCLASS "rdclass"
#define FROMSTRUCTTYPE "type"
#define FROMSTRUCTDEF "use_default = ISC_TRUE"

#define TOSTRUCTDECL "dns_rdata_t *rdata, void *target, isc_mem_t *mctx"
#define TOSTRUCTARGS "rdata, target, mctx"
#define TOSTRUCTCLASS "rdata->rdclass"
#define TOSTRUCTTYPE "rdata->type"
#define TOSTRUCTDEF "use_default = ISC_TRUE"

#define FREESTRUCTDECL "void *source"
#define FREESTRUCTARGS "source"
#define FREESTRUCTCLASS "common->rdclass"
#define FREESTRUCTTYPE "common->rdtype"
#define FREESTRUCTDEF NULL

#define COMPAREDECL "dns_rdata_t *rdata1, dns_rdata_t *rdata2"
#define COMPAREARGS "rdata1, rdata2"
#define COMPARECLASS "rdata1->rdclass"
#define COMPARETYPE "rdata1->type"
#define COMPAREDEF "use_default = ISC_TRUE"

#define ADDITIONALDATADECL \
    "dns_rdata_t *rdata, dns_additionaldatafunc_t add, void *arg"
#define ADDITIONALDATAARGS "rdata, add, arg"
#define ADDITIONALDATACLASS "rdata->rdclass"
#define ADDITIONALDATATYPE "rdata->type"
#define ADDITIONALDATADEF "use_default = ISC_TRUE"

#define DIGESTDECL \
    "dns_rdata_t *rdata, dns_digestfunc_t digest, void *arg"
#define DIGESTARGS "rdata, digest, arg"
#define DIGESTCLASS "rdata->rdclass"
#define DIGESTTYPE "rdata->type"
#define DIGESTDEF "use_default = ISC_TRUE"

char copyright[] =
"/*\n\
 * Copyright (C) 1998%s Internet Software Consortium.\n\
 *\n\
 * Permission to use, copy, modify, and distribute this software for any\n\
 * purpose with or without fee is hereby granted, provided that the above\n\
 * copyright notice and this permission notice appear in all copies.\n\
 *\n\
 * THE SOFTWARE IS PROVIDED \"AS IS\" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS\n\
 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES\n\
 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE\n\
 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL\n\
 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR\n\
 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS\n\
 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS\n\
 * SOFTWARE.\n\
 */\n\
\n\
 /* THIS FILE IS AUTOMATICALLY GENERATED: DO NOT EDIT */\n\
\n";

struct cc {
    struct cc *next;
    int rdclass;
    char classname[11];
} *classes;

struct tt {
    struct tt *next;
    int rdclass;
    int type;
    char classname[11];
    char typename[11];
    char dirname[256];      /* XXX Should be max path length */
} *types;

struct ttnam {
    char typename[11];
    char macroname[11];
} typenames[256];

char *  upper(char *);
char *  funname(char *, char *);
void    doswitch(char *, char *, char *, char *, char *, char *);
void    dodecl(char *, char *, char *);
void    add(int, char *, int, char *, char *);
void    sd(int, char *, char *, char);

/*
 * If you use more than 10 of these in, say, a printf(), you'll have problems.
 */
char *
upper(char *s) {
    static int buf_to_use = 0;
    static char buf[10][11];
    char *b;
    int c;

    buf_to_use++;
    if (buf_to_use > 9)
        buf_to_use = 0;

    b = buf[buf_to_use];

    while ((c = (*s++) & 0xff)) {

        *b++ = islower(c) ? toupper(c) : c;
    }
    *b = '\0';
    return (buf[buf_to_use]);
}

char *
funname(char *s, char *buf) {
    char *b = buf;
    char c;

    while ((c = *s++)) {
        *b++ = (c == '-') ? '_' : c;
    }
    *b = '\0';
    return (buf);
}

void
doswitch(char *name, char *function, char *args,
     char *tsw, char *csw, char *res)
{
    struct tt *tt;
    int first = 1;
    int lasttype = 0;
    int subswitch = 0;
    char buf1[11], buf2[11];
    char *result = " result =";

    if (res == NULL)
        result = "";

    for (tt = types; tt != NULL ; tt = tt->next) {
        if (first) {
            fprintf(stdout, "\n#define %s \\\n", name);
            fprintf(stdout, "\tswitch (%s) { \\\n" /*}*/, tsw);
            first = 0;
        }
        if (tt->type != lasttype && subswitch) {
            if (res == NULL)
                fprintf(stdout, "\t\tdefault: break; \\\n");
            else
                fprintf(stdout,
                    "\t\tdefault: %s; break; \\\n", res);
            fputs(/*{*/ "\t\t} \\\n", stdout);
            fputs("\t\tbreak; \\\n", stdout);
            subswitch = 0;
        }
        if (tt->rdclass && tt->type != lasttype) {
            fprintf(stdout, "\tcase %d: switch (%s) { \\\n" /*}*/,
                tt->type, csw);
            subswitch = 1;
        }
        if (tt->rdclass == 0)
            fprintf(stdout,
                "\tcase %d:%s %s_%s(%s); break;",
                tt->type, result, function,
                funname(tt->typename, buf1), args);
        else
            fprintf(stdout,
                    "\t\tcase %d:%s %s_%s_%s(%s); break;",
                tt->rdclass, result, function,
                funname(tt->classname, buf1),
                funname(tt->typename, buf2), args);
        fputs(" \\\n", stdout);
        lasttype = tt->type;
    }
    if (subswitch) {
        if (res == NULL)
            fprintf(stdout, "\t\tdefault: break; \\\n");
        else
            fprintf(stdout, "\t\tdefault: %s; break; \\\n", res);
        fputs(/*{*/ "\t\t} \\\n", stdout);
        fputs("\t\tbreak; \\\n", stdout);
    }
    if (first) {
        if (res == NULL)
            fprintf(stdout, "\n#define %s\n", name);
        else
            fprintf(stdout, "\n#define %s %s;\n", name, res);
    } else {
        if (res == NULL)
            fprintf(stdout, "\tdefault: break; \\\n");
        else
            fprintf(stdout, "\tdefault: %s; break; \\\n", res);
        fputs(/*{*/ "\t}\n", stdout);
    }
}

void
dodecl(char *type, char *function, char *args) {
    struct tt *tt;
    char buf1[11], buf2[11];

    fputs("\n", stdout);
    for (tt = types; tt ; tt = tt->next)
        if (tt->rdclass)
            fprintf(stdout,
                "static inline %s %s_%s_%s(%s);\n",
                type, function,
                funname(tt->classname, buf1),
                funname(tt->typename, buf2), args);
        else
            fprintf(stdout,
                "static inline %s %s_%s(%s);\n",
                type, function,
                funname(tt->typename, buf1), args);
}

void
add(int rdclass, char *classname, int type, char *typename, char *dirname) {
    struct tt *newtt = (struct tt *)malloc(sizeof *newtt);
    struct tt *tt, *oldtt;
    struct ttnam *ttn;
    struct cc *newcc;
    struct cc *cc, *oldcc;

    if (newtt == NULL) {
        fprintf(stderr, "malloc() failed\n");
        exit(1);
    }

    ttn = &typenames[type];
    if (ttn->typename[0] == 0) {
        if (strlen(typename) > sizeof(ttn->typename) - 1) {
            fprintf(stderr, "Error:  type name %s is too long\n",
                typename);
            exit(1);
        }
        strcpy(ttn->typename, typename);
    } else if (strcmp(typename, ttn->typename) != 0) {
        fprintf(stderr, "Error:  type %d has two names: %s, %s\n",
            type, ttn->typename, typename);
        exit(1);
    }

    newtt->next = NULL;
    newtt->rdclass = rdclass;
    newtt->type = type;
    strcpy(newtt->classname, classname);
    strcpy(newtt->typename, typename);
    strcpy(newtt->dirname, dirname);

    tt = types;
    oldtt = NULL;

    while ((tt != NULL) && (tt->type < type)) {
        oldtt = tt;
        tt = tt->next;
    }

    while ((tt != NULL) && (tt->type == type) && (tt->rdclass < rdclass)) {
        if (strcmp(tt->typename, typename) != 0)
            exit(1);
        oldtt = tt;
        tt = tt->next;
    }

    if ((tt != NULL) && (tt->type == type) && (tt->rdclass == rdclass))
        exit(1);

    newtt->next = tt;
    if (oldtt != NULL)
        oldtt->next = newtt;
    else
        types = newtt;

    /* do a class switch for this type */

    if (rdclass == 0)
        return;

    newcc = (struct cc *)malloc(sizeof *newcc);
    newcc->rdclass = rdclass;
    strcpy(newcc->classname, classname);
    cc = classes;
    oldcc = NULL;

    while ((cc != NULL) && (cc->rdclass < rdclass)) {
        oldcc = cc;
        cc = cc->next;
    }

    if ((cc != NULL) && cc->rdclass == rdclass) {
        free((char *)newcc);
        return;
    }

    newcc->next = cc;
    if (oldcc != NULL)
        oldcc->next = newcc;
    else
        classes = newcc;
}

void
sd(int rdclass, char *classname, char *dirname, char filetype) {
    char buf[sizeof "0123456789_65535.h"];
    char fmt[sizeof "%10[-0-9a-z]_%d.h"];
    int type;
    char typename[11];
    isc_dir_t dir;

    if (!start_directory(dirname, &dir))
        return;

    sprintf(fmt,"%s%c", "%10[-0-9a-z]_%d.", filetype);
    while (next_file(&dir)) {
        if (sscanf(dir.filename, fmt, typename, &type) != 2)
            continue;
        if ((type > 65535) || (type < 0))
            continue;

        sprintf(buf, "%s_%d.%c", typename, type, filetype);
        if (strcmp(buf, dir.filename) != 0)
            continue;
        add(rdclass, classname, type, typename, dirname);
    }

    end_directory(&dir);
}

int
main(int argc, char **argv) {
    char buf[256];          /* XXX Should be max path length */
    char srcdir[256];       /* XXX Should be max path length */
    int rdclass;
    char classname[11];
    struct tt *tt;
    struct cc *cc;
    struct ttnam *ttn;
    struct tm *tm;
    time_t now;
    char year[11];
    int lasttype;
    int code = 1;
    int class_enum = 0;
    int type_enum = 0;
    int structs = 0;
    int c, i;
    char buf1[11];
    char filetype = 'c';
    FILE *fd;
    char *prefix = NULL;
    char *suffix = NULL;
    isc_dir_t dir;
    int special;

    for (i = 0 ; i <= 255 ; i++) {
        memset(typenames[i].typename, 0,
               sizeof(typenames[i].typename));
        memset(typenames[i].macroname, 0,
               sizeof(typenames[i].macroname));
    }

    strcpy(srcdir, "");
    while ((c = isc_commandline_parse(argc, argv, "cits:P:S:")) != -1)
        switch (c) {
        case 'c':
            code = 0;
            type_enum = 0;
            class_enum = 1;
            filetype = 'c';
            structs = 0;
            break;
        case 't':
            code = 0;
            class_enum = 0;
            type_enum = 1;
            filetype = 'c';
            structs = 0;
            break;
        case 'i':
            code = 0;
            class_enum = 0;
            type_enum = 0;
            structs = 1;
            filetype = 'h';
            break;
        case 's':
            sprintf(srcdir, "%s/", isc_commandline_argument);
            break;
        case 'P':
            prefix = isc_commandline_argument;
            break;
        case 'S':
            suffix = isc_commandline_argument;
            break;
        case '?':
            exit(1);
        }

    sprintf(buf, "%srdata", srcdir);

    if (!start_directory(buf, &dir))
        exit(1);

    while (next_file(&dir)) {
        if (sscanf(dir.filename, "%10[0-9a-z]_%d",
               classname, &rdclass) != 2)
            continue;
        if ((rdclass > 65535) || (rdclass < 0))
            continue;

        sprintf(buf, "%srdata/%s_%d", srcdir, classname, rdclass);
        if (strcmp(buf + 6 + strlen(srcdir), dir.filename) != 0)
            continue;
        sd(rdclass, classname, buf, filetype);
    }
    end_directory(&dir);
    sprintf(buf, "%srdata/generic", srcdir);
    sd(0, "", buf, filetype);

    if (time(&now) != -1) {
        if ((tm = localtime(&now)) != NULL && tm->tm_year > 98)
            sprintf(year, "-%d", tm->tm_year + 1900);
        else
            year[0] = 0;
    } else
        year[0] = 0;

    fprintf(stdout, copyright, year);

    if (code) {
#if 0
        dodecl("isc_result_t", "fromtext", FROMTEXTDECL);
        dodecl("isc_result_t", "totext", TOTEXTDECL);
        dodecl("isc_result_t", "fromwire", FROMWIREDECL);
        dodecl("isc_result_t", "towire", TOWIREDECL);
        dodecl("int", "compare", COMPAREDECL);
        dodecl("isc_result_t", "fromstruct", FROMSTRUCTDECL);
        dodecl("isc_result_t", "tostruct", TOSTRUCTDECL);
        dodecl("void", "freestruct", FREESTRUCTDECL);
        dodecl("isc_result_t", "additionaldata", ADDITIONALDATADECL);
        dodecl("isc_result_t", "digest", DIGESTDECL);
#endif

        fputs("\n\n", stdout);
        for (tt = types; tt != NULL ; tt = tt->next)
            fprintf(stdout, "#include \"%s/%s_%d.c\"\n",
                tt->dirname, tt->typename, tt->type);
        fputs("\n\n", stdout);

        doswitch("FROMTEXTSWITCH", "fromtext", FROMTEXTARGS,
             FROMTEXTTYPE, FROMTEXTCLASS, FROMTEXTDEF);
        doswitch("TOTEXTSWITCH", "totext", TOTEXTARGS,
             TOTEXTTYPE, TOTEXTCLASS, TOTEXTDEF);
        doswitch("FROMWIRESWITCH", "fromwire", FROMWIREARGS,
             FROMWIRETYPE, FROMWIRECLASS, FROMWIREDEF);
        doswitch("TOWIRESWITCH", "towire", TOWIREARGS,
             TOWIRETYPE, TOWIRECLASS, TOWIREDEF);
        doswitch("COMPARESWITCH", "compare", COMPAREARGS,
              COMPARETYPE, COMPARECLASS, COMPAREDEF);
        doswitch("FROMSTRUCTSWITCH", "fromstruct", FROMSTRUCTARGS,
              FROMSTRUCTTYPE, FROMSTRUCTCLASS, FROMSTRUCTDEF);
        doswitch("TOSTRUCTSWITCH", "tostruct", TOSTRUCTARGS,
              TOSTRUCTTYPE, TOSTRUCTCLASS, TOSTRUCTDEF);
        doswitch("FREESTRUCTSWITCH", "freestruct", FREESTRUCTARGS,
              FREESTRUCTTYPE, FREESTRUCTCLASS, FREESTRUCTDEF);
        doswitch("ADDITIONALDATASWITCH", "additionaldata",
             ADDITIONALDATAARGS, ADDITIONALDATATYPE,
             ADDITIONALDATACLASS, ADDITIONALDATADEF);
        doswitch("DIGESTSWITCH", "digest",
             DIGESTARGS, DIGESTTYPE,
             DIGESTCLASS, DIGESTDEF);

        fprintf(stdout, "\n#define TYPENAMES%s\n",
            types != NULL ? " \\" : "");

        lasttype = 0;
        for (tt = types; tt != NULL ; tt = tt->next)
            if (tt->type != lasttype)
                fprintf(stdout, "\t{ %d, \"%s\", 0 },%s\n",
                    lasttype = tt->type,
                    upper(tt->typename),
                    tt->next != NULL ? " \\" : "");


        /*
         * Change "invalid" characters to valid ones.  In this
         * case, only worry about the - in the nsap-ptr and other
         * type names.
         */
        for (i = 0 ; i <= 255 ; i++) {
            ttn = &typenames[i];
            if (ttn->typename[0] == 0)
                continue;
            strcpy(ttn->macroname, ttn->typename);
            c = strlen(ttn->macroname);
            while (c > 0) {
                if (ttn->macroname[c - 1] == '-')
                    ttn->macroname[c - 1] = '_';
                c--;
            }
        }

#define PRINT_COMMA(x) (x == 255 ? "" : ",")

#define METANOTQUESTION  "DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_NOTQUESTION"
#define METAQUESTIONONLY "DNS_RDATATYPEATTR_META | DNS_RDATATYPEATTR_QUESTIONONLY"

        printf("\ntypedef struct {\n");
        printf("\tchar *name;\n");
        printf("\tunsigned int flags;\n");
        printf("} typeattr_t;\n");
        printf("static typeattr_t typeattr[] = {\n");
        for (i = 0 ; i <= 255 ; i++) {
            ttn = &typenames[i];
            special = 0;
            switch (i) {
            case 0:
                printf("\t{ \"RESERVED0\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 31:
                printf("\t{ \"EID\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 32:
                printf("\t{ \"NIMLOC\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 34:
                printf("\t{ \"ATMA\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 100:
                printf("\t{ \"UINFO\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 101:
                printf("\t{ \"UID\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 102:
                printf("\t{ \"GID\", "
                       "DNS_RDATATYPEATTR_RESERVED }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 251:
                printf("\t{ \"IXFR\", "
                       METANOTQUESTION " }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 252:
                printf("\t{ \"AXFR\", "
                       METANOTQUESTION " }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 253:
                printf("\t{ \"MAILB\", "
                       "DNS_RDATATYPEATTR_META }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 254:
                printf("\t{ \"MAILA\", "
                       "DNS_RDATATYPEATTR_META }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            case 255:
                printf("\t{ \"ANY\", "
                       METAQUESTIONONLY " }%s\n",
                       PRINT_COMMA(i));
                special = 1;
                break;
            default:
                if (ttn->typename[0] == 0) {

                    printf("\t{ \"RRTYPE%d\", "
                           "DNS_RDATATYPEATTR_UNKNOWN"
                           "}%s\n", i, PRINT_COMMA(i));
                } else {
                printf("\t{ \"%s\", "
                       "RRTYPE_%s_ATTRIBUTES }%s\n",
                       upper(ttn->typename),
                       upper(ttn->macroname),
                       PRINT_COMMA(i));
                }
                break;
            }

            if (special == 1 && ttn->typename[0] != 0) {
                fprintf(stderr, "Error!  Special processing for %s, but type is defined in a file also\n",
                       ttn->typename);
                exit(1);
            }
        }
        printf("};\n");


        fputs("\n", stdout);
        fprintf(stdout, "\n#define CLASSNAMES%s\n",
            classes != NULL ? " \\" : "");

        for (cc = classes; cc != NULL; cc = cc->next)
            fprintf(stdout, "\t{ %d, \"%s\", 0 },%s\n",
                cc->rdclass, upper(cc->classname),
                cc->next != NULL ? " \\" : "");

        fputs("\n", stdout);
    } else if (type_enum) {
        fprintf(stdout, "#ifndef TYPEENUM\n");
        fprintf(stdout, "#define TYPEENUM%s\n",
            types != NULL ? " \\" : "");

        lasttype = 0;
        for (tt = types; tt != NULL ; tt = tt->next)
            if (tt->type != lasttype)
                fprintf(stdout, "\t dns_rdatatype_%s = %d,%s\n",
                    funname(tt->typename, buf1),
                    lasttype = tt->type,
                    tt->next != NULL ? " \\" : "");
        fprintf(stdout, "#endif /* TYPEENUM */\n");
    } else if (class_enum) {
        fprintf(stdout, "#ifndef CLASSENUM\n");
        fprintf(stdout, "#define CLASSENUM%s\n",
            classes != NULL ? " \\" : "");

        for (cc = classes; cc != NULL; cc = cc->next)
            fprintf(stdout, "\t dns_rdataclass_%s = %d,%s\n",
                funname(cc->classname, buf1),
                cc->rdclass,
                cc->next != NULL ? " \\" : "");
        fprintf(stdout, "#endif /* CLASSENUM */\n");
    } else if (structs) {
        if (prefix != NULL) {
            if ((fd = fopen(prefix,"r")) != NULL) {
                while (fgets(buf, sizeof buf, fd) != NULL)
                    fputs(buf, stdout);
                fclose(fd);
            }
        }
        for (tt = types; tt != NULL ; tt = tt->next) {
            sprintf(buf, "%s/%s_%d.h",
                tt->dirname, tt->typename, tt->type);
            if ((fd = fopen(buf,"r")) != NULL) {
                while (fgets(buf, sizeof buf, fd) != NULL)
                    fputs(buf, stdout);
                fclose(fd);
            }
        }
        if (suffix != NULL) {
            if ((fd = fopen(suffix,"r")) != NULL) {
                while (fgets(buf, sizeof buf, fd) != NULL)
                    fputs(buf, stdout);
                fclose(fd);
            }
        }
    }

    if (ferror(stdout) != 0)
        exit(1);

    return (0);
}