/*

 * dump-sppi.c --

 *

 *      Operations to dump SPPI module information.

 *

 * Copyright (c) 1999 Frank Strauss, Technical University of Braunschweig.

 *

 * See the file "COPYING" for information on usage and redistribution

 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.

 *

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#include "smi.h"

#include "smidump.h"

#define  INDENT		4    /* indent factor */

#define  INDENTVALUE	16   /* column to start values, except multiline */

#define  INDENTTEXTS	 9   /* column to start multiline texts */

#define  INDENTMAX	72   /* max column to fill, break lines otherwise */

static char *convertType[] = {

    NULL,		 "INTEGER",	       NULL,	   "Integer32",

    NULL,		 "Bits",	       NULL,	   "BITS",

    NULL,		 "OctetString",	       NULL,	   "OCTET STRING",

    NULL,		 "ObjectIdentifier",   NULL,	   "OBJECT IDENTIFIER",

    NULL,		 "IpAddress",          NULL,	   "InetAddress",

    NULL,		 "Counter64",          NULL,	   "Unsigned64",

    NULL,		 "Counter32",          NULL,	   "Unsigned32",

    NULL,		 "Gauge32",            NULL,	   "Unsigned32",

    NULL, NULL, NULL, NULL };

static char *convertTypeMibToPib[] = {

    NULL,		 "SnmpAdminString",    NULL,	   "OCTET STRING",

    NULL, NULL, NULL, NULL };

static char *convertImport[] = {

    "SNMPv2-SMI", "Integer32",      "COPS-PR-SPPI", "Integer32",

    "SNMPv2-SMI", "Unsigned32",     "COPS-PR-SPPI", "Unsigned32",

    "SNMPv2-SMI", "TimeTicks",      "COPS-PR-SPPI", "TimeTicks",

    "SNMPv2-SMI", "IpAddress",      "INET-ADDRESS-MIB", "InetAddress",

    "SNMPv2-SMI", "MODULE-IDENTITY","COPS-PR-SPPI", "MODULE-IDENTITY",

    "SNMPv2-SMI", "MODULE-COMPLIANCE","COPS-PR-SPPI", "MODULE-COMPLIANCE",

    "SNMPv2-SMI", "OBJECT-TYPE",    "COPS-PR-SPPI", "OBJECT-TYPE",

    "SNMPv2-SMI", "OBJECT-IDENTITY","COPS-PR-SPPI", "OBJECT-IDENTITY",

    "SNMPv2-TC",  "TEXTUAL-CONVENTION","COPS-PR-SPPI", "TEXTUAL-CONVENTION",

    NULL, NULL, NULL, NULL };

static int current_column = 0;

static int silent = 0;

static int mibtopib = 0;

typedef struct Import {

    char          *module;

    char          *name;

    struct Import *nextPtr;

} Import;

static Import *importList = NULL;

static int invalidType(SmiBasetype basetype)

{

    return (basetype == SMI_BASETYPE_FLOAT32)

	|| (basetype == SMI_BASETYPE_FLOAT64)

	|| (basetype == SMI_BASETYPE_FLOAT128);

}

static char *getStatusString(SmiStatus status)

{

    return

	(status == SMI_STATUS_CURRENT)     ? "current" :

	(status == SMI_STATUS_DEPRECATED)  ? "deprecated" :

	(status == SMI_STATUS_OBSOLETE)    ? "obsolete" :

					     "<unknown>";

}

static char *getAccessString(SmiAccess access, int pibaccess)

{

    return

        (access == SMI_ACCESS_NOTIFY)	      ? "notify" :

        (access == SMI_ACCESS_INSTALL)	      ? "install" :

        (access == SMI_ACCESS_INSTALL_NOTIFY) ? "install-notify" :

        (access == SMI_ACCESS_REPORT_ONLY)    ? "report-only" :

        (access == SMI_ACCESS_NOT_ACCESSIBLE) ?

             (pibaccess == 1 ? "report-only" : "not-accessible") :

        mibtopib                              ? "notify" : 

					        "<unknown>";

}

static int isSmiOnlyType(char *type)

{

    return (!strcmp(type, "Counter32") ||

            !strcmp(type, "Counter64") ||

            !strcmp(type, "Gauge32"));

}

static char *getTimeString(time_t t)

{

    static char   *s = NULL;

    struct tm	  *tm;

    if (s) xfree(s);

    tm = gmtime(&t);

    smiAsprintf(&s, "%04d%02d%02d%02d%02dZ",

		tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,

		tm->tm_hour, tm->tm_min);

    return s;

}

static char *getTypeString(SmiBasetype basetype, SmiType *smiType)

{

    int         i;

    char        *typeModule, *typeName;

    typeName = smiType ? smiType->name : NULL;

    typeModule = smiType ? smiGetTypeModule(smiType)->name : NULL;

    if (typeName &&

	(basetype != SMI_BASETYPE_ENUM) &&

	(basetype != SMI_BASETYPE_BITS)) {

        if (mibtopib)

            for(i=0; convertTypeMibToPib[i+1]; i += 4) {

	        if ((!strcmp(typeName, convertTypeMibToPib[i+1])) &&

	            ((!typeModule) || (!convertTypeMibToPib[i]) ||

	             (!strcmp(typeModule, convertTypeMibToPib[i])))) {

	            return convertTypeMibToPib[i+3];

	        }

            }

	for(i=0; convertType[i+1]; i += 4) {

	    if ((!strcmp(typeName, convertType[i+1])) &&

		((!typeModule) || (!convertType[i]) ||

		 (!strcmp(typeModule, convertType[i])))) {

		return convertType[i+3];

	    }

	}

    }

    if ((!typeModule) || (!strlen(typeModule)) || (!typeName)) {

	if (basetype == SMI_BASETYPE_ENUM) {

	    return "INTEGER";

	}

	if (basetype == SMI_BASETYPE_BITS) {

            return "BITS";

	}

    }

    /* TODO: fully qualified if unambigous */

    return typeName;

}

static char *getOidString(SmiNode *smiNode, int importedParent)

{

    SmiNode	 *parentNode;

    SmiModule	 *smiModule;

    static char	 s[200];

    char	 append[200];

    unsigned int i;

    append[0] = 0;

    parentNode = smiNode;

    smiModule = smiGetNodeModule(smiNode);

    do {

	if (parentNode->oidlen <= 1) {

	    break;

	}

	/* prepend the cut-off subidentifier to `append'. */

	strcpy(s, append);

	sprintf(append, " %u%s", parentNode->oid[parentNode->oidlen-1], s);

	/* retrieve the parent SmiNode */

	parentNode = smiGetParentNode(parentNode);

	if (!parentNode) {

	    sprintf(s, "%s", append);

	    return s;

	}

	/* found an imported or a local parent node? */

	if ((parentNode->name && strlen(parentNode->name)) &&

	    (smiIsImported(smiModule, NULL, parentNode->name) ||

	     (!importedParent &&

	      (smiGetNodeModule(parentNode) == smiModule)) ||

	     (parentNode->oidlen == 1))) {

	    sprintf(s, "%s%s", parentNode->name, append);

	    return s;

	}

    } while (parentNode);

    s[0] = 0;

    for (i=0; i < smiNode->oidlen; i++) {

	if (i) strcat(s, " ");

	sprintf(&s[strlen(s)], "%u", smiNode->oid[i]);

    }

    return s;

}

static char *getUppercaseString(char *s)

{

    static char *ss;

    ss = xstrdup(s);

    ss[0] = (char)toupper((int)ss[0]);

    return ss;

}

static int isObjectGroup(SmiNode *groupNode)

{

    SmiNode     *smiNode;

    SmiElement  *smiElement;

    for (smiElement = smiGetFirstElement(groupNode); smiElement;

	 smiElement = smiGetNextElement(smiElement)) {

	smiNode = smiGetElementNode(smiElement);

	if (smiNode->nodekind != SMI_NODEKIND_SCALAR

	    && smiNode->nodekind != SMI_NODEKIND_COLUMN) {

	    return 0;

	}

    }

    return 1;

}

static Import* addImport(char *module, char *name)

{

    Import **import, *newImport;

    int    i;

    for (i = 0; convertImport[i]; i += 4) {

	if (convertImport[i] && convertImport[i+1]

	    && !strcmp(module, convertImport[i])

	    && !strcmp(name, convertImport[i+1])) {

	    module = convertImport[i+2];

	    name = convertImport[i+3];

	    break;

	} else if (convertImport[i] && !convertImport[i+1]

		   && !strcmp(module, convertImport[i])) {

	    module = convertImport[i+2];

	    break;

	}

    }

    if (!module || !name) {

	return NULL;

    }

    for (import = &importList; *import; import = &(*import)->nextPtr) {

	int c = strcmp((*import)->module, module);

	if (c < 0) continue;

	if (c == 0) {

	    int d = strcmp((*import)->name, name);

	    if (d < 0) continue;

	    if (d == 0) return *import;

	    if (d > 0) break;

	}

	if (c > 0) break;

    }

    newImport = xmalloc(sizeof(Import));

    if (! newImport) {

	return NULL;

    }

    newImport->module = module;

    newImport->name = name;

    newImport->nextPtr = *import;

    *import = newImport;

    return *import;

}

static void createImportList(SmiModule *smiModule)

{

    SmiNode     *smiNode;

    SmiType     *smiType;

    SmiNodekind kind = SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN;

    SmiImport   *smiImport;

    SmiModule	*smiModule2;

    if (mibtopib) {

        addImport("TUBS-SMI", "ibrmibtopib");

        if (smiGetFirstNode(smiModule, SMI_NODEKIND_COLUMN)) {

            addImport("COPS-PR-SPPI", "MODULE-COMPLIANCE");

            addImport("COPS-PR-SPPI", "OBJECT-GROUP");

            addImport("COPS-PR-SPPI", "OBJECT-IDENTITY");

            addImport("COPS-PR-SPPI-TC", "InstanceId");

        }

    }

    for(smiNode = smiGetFirstNode(smiModule, kind); smiNode;

	smiNode = smiGetNextNode(smiNode, kind)) {

	smiType = smiGetNodeType(smiNode);

	if (smiType && (smiType->decl == SMI_DECL_IMPLICIT_TYPE)) {

	    smiType = smiGetParentType(smiType);

	}

	if (smiType) {

	    smiModule2 = smiGetTypeModule(smiType);

	    if (smiModule2 && (smiModule2 != smiModule)) {

		if (strlen(smiModule2->name) && smiType->name &&

                    !isSmiOnlyType(smiType->name)) {

		    addImport(smiModule2->name, smiType->name);

		}

	    }

	}

	if (smiType && smiType->basetype == SMI_BASETYPE_INTEGER32) {

	    addImport("COPS-PR-SPPI", "Integer32");

	}

	if (smiType && smiType->basetype == SMI_BASETYPE_INTEGER64) {

	    addImport("COPS-PR-SPPI", "Integer64");

	}

	if (smiType && smiType->basetype == SMI_BASETYPE_UNSIGNED32) {

	    addImport("COPS-PR-SPPI", "Unsigned32");

	}

	if (smiType && smiType->basetype == SMI_BASETYPE_UNSIGNED64) {

	    addImport("COPS-PR-SPPI", "Unsigned64");

	}

	if ((smiNode->value.basetype == SMI_BASETYPE_OBJECTIDENTIFIER) &&

	    (!strcmp(smiNode->value.value.ptr, "zeroDotZero"))) {

	    addImport("SNMPv2-SMI", "zeroDotZero");

	}

    }

    smiNode = smiGetFirstNode(smiModule,

			      SMI_NODEKIND_SCALAR | SMI_NODEKIND_COLUMN

			      | SMI_NODEKIND_TABLE | SMI_NODEKIND_ROW);

    if (smiNode) {

	addImport("COPS-PR-SPPI", "OBJECT-TYPE");

    }

    smiNode = smiGetModuleIdentityNode(smiModule);

    if (smiNode) {

	if (strcmp("COPS-PR-SPPI", smiModule->name)) {

	    addImport("COPS-PR-SPPI", "MODULE-IDENTITY");

	}

    }

    for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_NODE);

	smiNode; smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_NODE)) {

	if (smiNode->status != SMI_STATUS_UNKNOWN &&

	    smiNode != smiGetModuleIdentityNode(smiModule)) {

	    if (strcmp("COPS-PR-SPPI", smiModule->name)) {

		addImport("COPS-PR-SPPI", "OBJECT-IDENTITY");

	    }

	    break;

	}

    }

    smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_COMPLIANCE);

    if (smiNode) {

	if (strcmp("COPS-PR-SPPI", smiModule->name)) {

	    addImport("COPS-PR-SPPI", "MODULE-COMPLIANCE");

	}

    }

    for(smiNode = smiGetFirstNode(smiModule, SMI_NODEKIND_GROUP);

	smiNode;

	smiNode = smiGetNextNode(smiNode, SMI_NODEKIND_GROUP)) {

	if (strcmp("COPS-PR-SPPI", smiModule->name)) {

	    addImport("COPS-PR-SPPI", "OBJECT-GROUP");

	}

    }

    for(smiType = smiGetFirstType(smiModule);

	smiType; smiType = smiGetNextType(smiType)) {

	if (smiType->description) {

	    if (strcmp("COPS-PR-SPPI", smiModule->name)) {

		addImport("COPS-PR-SPPI", "TEXTUAL-CONVENTION");

	    }

	}

        if (smiType->decl == SMI_DECL_TEXTUALCONVENTION) {

            switch (smiType->basetype) {

	    case SMI_BASETYPE_INTEGER32:

		addImport("COPS-PR-SPPI", "Integer32");

		break;

	    case SMI_BASETYPE_INTEGER64:

		addImport("COPS-PR-SPPI", "Integer64");

		break;

	    case SMI_BASETYPE_UNSIGNED32:

		addImport("COPS-PR-SPPI", "Unsigned32");

		break;

	    case SMI_BASETYPE_UNSIGNED64:

		addImport("COPS-PR-SPPI", "Unsigned64");

		break;

	    default:

		break;

            }

        }

    }

    for (smiImport = smiGetFirstImport(smiModule); smiImport;

	 smiImport = smiGetNextImport(smiImport)) {

	if ((islower((int) smiImport->name[0]) ||

	    (smiImport->module && !strcmp(smiImport->module, "SNMPv2-SMI")) ||

	    (smiImport->module && !strcmp(smiImport->module, "SNMPv2-TC"))) &&

            !isSmiOnlyType(smiImport->name)) {

	    addImport(smiImport->module, smiImport->name);

	}

    }

}

static void freeImportList(void)

{

    Import *import, *freeme;

    for (import = importList; import; ) {

	freeme = import;

	import = import->nextPtr;

	xfree(freeme);

    }

    importList = NULL;

}

static void fprint(FILE *f, char *fmt, ...)

{

    va_list ap;

    char    *s;

    char    *p;

    va_start(ap, fmt);

    current_column += smiVasprintf(&s, fmt, ap);

    va_end(ap);

    fputs(s, f);

    if ((p = strrchr(s, '\n'))) {

	current_column = strlen(p) - 1;

    }

    free(s);

}

static void fprintSegment(FILE *f, int column, char *string,

			  int length, int comment)

{

    char *format;

    if (comment) {

	format = "-- %*c%s";

	/* if (column >= 3) column -= 3; */

    } else {

	format = "%*c%s";

    }

    fprint(f, format, column, ' ', string);

    if (length) {

	fprint(f, "%*c", length - strlen(string) - column, ' ');

    }

}

static void fprintWrapped(FILE *f, int column, char *string, int comment)

{

    if ((current_column + strlen(string)) > INDENTMAX) {

	putc('\n', f);

	current_column = 0;

	fprintSegment(f, column, "", 0, comment);

    }

    fprint(f, "%s", string);

}

static void fprintMultilineString(FILE *f, const char *s, const int comment)

{

    int i, len;

    fprintSegment(f, INDENTTEXTS - 1, "\"", 0, comment);

    if (s) {

	len = strlen(s);

	for (i=0; i < len; i++) {

	    putc(s[i], f);

	    current_column++;

	    if (s[i] == '\n') {

		current_column = 0;

		fprintSegment(f, INDENTTEXTS, "", 0, comment);

	    }

	}

    }

    putc('\"', f);

    current_column++;

}

static char *getValueString(SmiValue *valuePtr, SmiType *typePtr)

{

    static char    s[1024];

    char           ss[9];

    int		   n;

    unsigned int   i;

    SmiNamedNumber *nn;

    SmiNode        *nodePtr;

    s[0] = 0;

    switch (valuePtr->basetype) {

    case SMI_BASETYPE_UNSIGNED32:

	sprintf(s, "%lu", valuePtr->value.unsigned32);

	break;

    case SMI_BASETYPE_INTEGER32:

	sprintf(s, "%ld", valuePtr->value.integer32);

	break;

    case SMI_BASETYPE_UNSIGNED64:

	sprintf(s, UINT64_FORMAT, valuePtr->value.unsigned64);

	break;

    case SMI_BASETYPE_INTEGER64:

	sprintf(s, INT64_FORMAT, valuePtr->value.integer64);

	break;

    case SMI_BASETYPE_ENUM:

	for (nn = smiGetFirstNamedNumber(typePtr); nn;

	     nn = smiGetNextNamedNumber(nn)) {

	    if (nn->value.value.unsigned32 == valuePtr->value.unsigned32)

		break;

	}

	if (nn) {

	    sprintf(s, "%s", nn->name);

	} else {

	    sprintf(s, "%ld", valuePtr->value.integer32);

	}

	break;

    case SMI_BASETYPE_OCTETSTRING:

	for (i = 0; i < valuePtr->len; i++) {

	    if (!isprint((int)valuePtr->value.ptr[i])) break;

	}

	if (i == valuePtr->len) {

	    sprintf(s, "\"%s\"", valuePtr->value.ptr);

	} else {

            sprintf(s, "'%*s'H", 2 * valuePtr->len, " ");

            for (i=0; i < valuePtr->len; i++) {

                sprintf(ss, "%02x", valuePtr->value.ptr[i]);

                strncpy(&s[1+2*i], ss, 2);

            }

	}

	break;

    case SMI_BASETYPE_BITS:

	sprintf(s, "{");

	for (i = 0, n = 0; i < valuePtr->len * 8; i++) {

	    if (valuePtr->value.ptr[i/8] & (1 << (7-(i%8)))) {

		for (nn = smiGetFirstNamedNumber(typePtr); nn;

		     nn = smiGetNextNamedNumber(nn)) {

		    if (nn->value.value.unsigned32 == i)

			break;

		}

		if (nn) {

		    if (n)

			sprintf(&s[strlen(s)], ", ");

		    n++;

		    sprintf(&s[strlen(s)], "%s", nn->name);

		}

	    }

	}

	sprintf(&s[strlen(s)], "}");

	break;

    case SMI_BASETYPE_FLOAT32:

    case SMI_BASETYPE_FLOAT64:

    case SMI_BASETYPE_FLOAT128:

    case SMI_BASETYPE_UNKNOWN:

    case SMI_BASETYPE_POINTER:

	break;

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	nodePtr = smiGetNodeByOID(valuePtr->len, valuePtr->value.oid);

	if (nodePtr) {

	    sprintf(s, "%s", nodePtr->name);

	} else {

	    strcpy(s, "{");

	    for (i=0; i < valuePtr->len; i++) {

		if (i) strcat(s, " ");

		sprintf(&s[strlen(s)], "%u", valuePtr->value.oid[i]);

	    }

	    strcat(s, "}");

	}

	break;

    }

    return s;

}

static void fprintSubtype(FILE *f, SmiType *smiType, const int comment)

{

    SmiRange       *range;

    SmiNamedNumber *nn;

    char	   s[1024];

    int		   i;

    if ((smiType->basetype == SMI_BASETYPE_ENUM) ||

	(smiType->basetype == SMI_BASETYPE_BITS)) {

	for(i = 0, nn = smiGetFirstNamedNumber(smiType);

	    nn; i++, nn = smiGetNextNamedNumber(nn)) {

	    if (i) {

		fprint(f, ", ");

	    } else {

		if (comment) {

		    fprint(f, "\n");

		    fprintSegment(f, INDENT, "", INDENTVALUE, comment);

		    fprint(f, "  { ");

		} else {

		    fprint(f, " { ");

		}

	    }

	    sprintf(s, "%s(%s)", nn->name,

		    getValueString(&nn->value, smiType));

	    fprintWrapped(f, INDENTVALUE + INDENT, s, comment);

	}

	if (i) {

	    fprint(f, " }");

	}

    } else {

	for(i = 0, range = smiGetFirstRange(smiType);

	    range; i++, range = smiGetNextRange(range)) {

	    if (i) {

		fprint(f, " | ");

	    } else {

		if (smiType->basetype == SMI_BASETYPE_OCTETSTRING) {

		    fprint(f, " (SIZE(");

		} else {

		    fprint(f, " (");

		}

	    }	    

	    if (memcmp(&range->minValue, &range->maxValue,

		       sizeof(SmiValue))) {

		sprintf(s, "%s", getValueString(&range->minValue, smiType));

		sprintf(&s[strlen(s)], "..%s", 

			getValueString(&range->maxValue, smiType));

	    } else {

		sprintf(s, "%s", getValueString(&range->minValue, smiType));

	    }

	    fprintWrapped(f, INDENTVALUE + INDENT, s, 0);

	}

	if (i) {

	    if (smiType->basetype == SMI_BASETYPE_OCTETSTRING) {

		fprint(f, ")");

	    }

	    fprint(f, ")");

	}

    }

}

static void fprintIndex(FILE *f, SmiNode *indexNode, const int comment)

{

    SmiElement *smiElement;

    int        n, j;

    /* PIBs can contain both a PIB-INDEX | EXTENDS | AUGMENTS and an

       INDEX clause. The index list's first element is the PIB-INDEX

       (or EXTENDS/AUGMENTS) followed by the elements belonging to the

       INDEX clause. */

    for (n = 0, smiElement = smiGetFirstElement(indexNode); smiElement;

	 n++, smiElement = smiGetNextElement(smiElement));

    if (mibtopib) {

        SmiNode *smiParentNode = smiGetParentNode(indexNode);

        size_t len = strlen(smiParentNode->name);

        char *instanceId = xmalloc(len + 11);

        strcpy(instanceId, smiParentNode->name);

        if (len > 54)

          len = 54;

        strcpy(&instanceId[len], "InstanceId");

        fprintSegment(f, INDENT, "PIB-INDEX", INDENTVALUE, 0);

        fprint(f, "{ ");

        fprintWrapped(f, INDENTVALUE + 2, instanceId, 0);

        fprint(f, " }\n");

        fprintSegment(f, INDENT, "INDEX", INDENTVALUE, 0);

        fprint(f, "{ ");

        for (j = 0, smiElement = smiGetFirstElement(indexNode); smiElement;

	     j++, smiElement = smiGetNextElement(smiElement)) {

             if (j)

                 fprint(f, ", ");

             fprintWrapped(f, INDENTVALUE + 2,

                           smiGetElementNode(smiElement)->name, 0);

        }

        xfree(instanceId);

    }

    else

        for (j = 0, smiElement = smiGetFirstElement(indexNode); smiElement;

	     j++, smiElement = smiGetNextElement(smiElement)) {

            if (!j) {

                switch (indexNode->indexkind) {

                    case SMI_INDEX_INDEX:

                        fprintSegment(f, INDENT, "PIB-INDEX", INDENTVALUE,

                                      comment);

                        break;

                    case SMI_INDEX_AUGMENT:

                        fprintSegment(f, INDENT, "AUGMENTS", INDENTVALUE,

                                      comment);

                        break;

                    case SMI_INDEX_SPARSE:

                        fprintSegment(f, INDENT, "EXTENDS", INDENTVALUE,

                                      comment);

                        break;

		    case SMI_INDEX_UNKNOWN:

		    case SMI_INDEX_REORDER:

		    case SMI_INDEX_EXPAND:

                        fprintSegment(f, INDENT, "-- unsupported indexing --",

				      INDENTVALUE, comment);

			break;

                }

                fprint(f, "{ ");

            } else if (j == 1) {

                fprint(f, " }\n");

                fprintSegment(f, INDENT, "INDEX", INDENTVALUE, comment);

                fprint(f, "{ ");

            } else

	        fprint(f, ", ");

	    if (indexNode->implied && ((j+1) == n)) {

	        fprintWrapped(f, INDENTVALUE + 2, "IMPLIED ", 0);

	    }

	    fprintWrapped(f, INDENTVALUE + 2,

		          smiGetElementNode(smiElement)->name, 0);

	    /* TODO: non-local name if non-local */

        } /* TODO: empty? -> print error */

    fprint(f, " }\n");

}

static void fprintUniqueness(FILE *f, SmiNode *indexNode, const int comment)

{

    SmiElement *smiElement;

    int        j;

    smiElement = smiGetFirstUniquenessElement(indexNode);

    if (!smiElement)

        return;

    fprintSegment(f, INDENT, "UNIQUENESS", INDENTVALUE, comment);

    fprint(f, "{ ");

    for (j = 0; smiElement; j++,

         smiElement = smiGetNextElement(smiElement)) {

        if (j)

	    fprint(f, ", ");

	fprintWrapped(f, INDENTVALUE + 2,

		      smiGetElementNode(smiElement)->name, 0);

	/* TODO: non-local name if non-local */

    } /* TODO: empty? -> print error */

    fprint(f, " }\n");

}

static void fprintInstallErrors(FILE *f, SmiNode *indexNode, const int comment)

{

    SmiElement *smiElement;

    SmiNode    *smiNode;

    int        j;

    char       *id;

    smiElement = smiGetFirstElement(indexNode);

    if (!smiElement)

        return;

    fprintSegment(f, INDENT, "INSTALL-ERRORS", INDENTVALUE, comment);

    fprint(f, "{ ");

    for (j = 0; smiElement; j++,

         smiElement = smiGetNextElement(smiElement)) {

        smiNode = smiGetElementNode(smiElement);

        id = xmalloc(strlen(smiNode->name) + 10);

        sprintf(id, "%s (%ld)%s", smiNode->name,

                smiNode->oidlen ? (long)smiNode->oid : 0,

                smiGetNextElement(smiElement) ? ", " : "");

        fprintWrapped(f, 2+INDENTVALUE, id, 0);

        xfree(id);

	/* TODO: non-local name if non-local */

    } /* TODO: empty? -> print error */

    fprint(f, " }\n");

}

static void fprintImports(FILE *f)

{

    Import        *import;

    char	  *lastModulename = NULL;

    char	  *importedModulename, *importedDescriptor;

    int		  i;

    for(import = importList; import; import = import->nextPtr) {

	importedModulename = import->module;

	importedDescriptor = import->name;

	if (!strlen(importedModulename))

	    continue;

	for(i = 0; convertImport[i]; i += 4) {

	    if (convertImport[i] && convertImport[i+1]

		&& !strcmp(importedModulename, convertImport[i])

		&& !strcmp(importedDescriptor, convertImport[i+1])) {

		importedModulename = convertImport[i+2];

		importedDescriptor = convertImport[i+3];

		break;

	    } else if (convertImport[i] && !convertImport[i+1]

		       && !strcmp(importedModulename, convertImport[i])) {

		importedModulename = convertImport[i+2];

		break;

	    }

	}

	if (importedModulename && importedDescriptor &&

	    strlen(importedDescriptor)) {

	    if ((!lastModulename) ||

		strcmp(importedModulename, lastModulename)) {

		if (!lastModulename) {

		    fprint(f, "IMPORTS");

		} else {

		    fprint(f, "\n");

		    fprintSegment(f, 2 * INDENT, "", 0, 0);

		    fprint(f, "FROM %s", lastModulename);

		}

		fprint(f, "\n");

		fprintSegment(f, INDENT, "", 0, 0);

	    } else {

		fprint(f, ", ");

	    }

	    fprintWrapped(f, INDENT, importedDescriptor, 0);

	    lastModulename = importedModulename;

	}

    }

    if (lastModulename) {

	fprint(f, "\n");

	fprintSegment(f, 2 * INDENT, "", 0, 0);

	fprint(f, "FROM %s;\n\n", lastModulename);

    }

}

static void fprintModuleIdentity(FILE *f, SmiModule *smiModule)

{

    SmiRevision  *smiRevision;

    SmiNode      *smiNode, *smiNode2;

    SmiElement   *smiElement;

    char         *id;