/*

 * dump-xsd.c --

 *

 *      Operations to dump SMI module information as XML schema definitions.

 *

 * Copyright (c) 2001 J. Schoenwaelder, Technical University of Braunschweig.

 *           (c) 2002 T. Klie, Technical University of Braunschweig.

 *           (c) 2002 F. Strauss, Technical University of Braunschweig.

 *           (c) 2007 T. Klie, Technical University of Braunschweig.

 *

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

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

 *

 * @(#) $Id: dump-xsd.c 8090 2008-04-18 12:56:29Z strauss $

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <ctype.h>

#include <time.h>

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "smi.h"

#include "smidump.h"

#include "fortopat.h"

#define  INDENT		2    /* indent factor */

static int ind = 0;

#ifndef MIN

#define MIN(a,b) ((a)) < ((b)) ? ((a)) : ((b))

#endif /* #ifndef MIN */

static char *schemaLocation = "http://www.ibr.cs.tu-bs.de/projects/libsmi/xsd/";

static int container = 0;

static char *containerBasename = "container";

static int *nestAugmentedTables = 0;

static int *nestSubtables = 0;

typedef struct XmlEscape {

    char character;

    char *escape;

} XmlEscape;

static XmlEscape xmlEscapes [] = {

    { '<',	"<" },

    { '>',	">" },

    { '&',	"&" },

    { 0,	NULL }

};

typedef struct TypePrefix {

    char *type;

    char *prefix;

    struct TypePrefix *next;

} TypePrefix;

static TypePrefix *typePrefixes = NULL;

/* some forward declarations */

static void fprintElement( FILE *f, SmiNode *smiNode, SmiNode *parentNode );

static char* getTypePrefix( char *typeName );

static char *getStringBasetype(SmiBasetype basetype)

{

    return

        (basetype == SMI_BASETYPE_UNKNOWN)           ? "<UNKNOWN>" :

        (basetype == SMI_BASETYPE_OCTETSTRING)       ? "OctetString" :

        (basetype == SMI_BASETYPE_OBJECTIDENTIFIER)  ? "ObjectIdentifier" :

        (basetype == SMI_BASETYPE_UNSIGNED32)        ? "Unsigned32" :

        (basetype == SMI_BASETYPE_INTEGER32)         ? "Integer32" :

        (basetype == SMI_BASETYPE_UNSIGNED64)        ? "Unsigned64" :

        (basetype == SMI_BASETYPE_INTEGER64)         ? "Integer64" :

        (basetype == SMI_BASETYPE_FLOAT32)           ? "Float32" :

        (basetype == SMI_BASETYPE_FLOAT64)           ? "Float64" :

        (basetype == SMI_BASETYPE_FLOAT128)          ? "Float128" :

        (basetype == SMI_BASETYPE_ENUM)              ? "Enumeration" :

        (basetype == SMI_BASETYPE_BITS)              ? "Bits" :

                                                   "<unknown>";

}

static char* getStringStatus(SmiStatus status)

{

    char *statStr;

    switch( status ) {

    case SMI_STATUS_CURRENT:

	statStr = "current";

	break;

    case SMI_STATUS_DEPRECATED:

	statStr = "deprecated";

	break;

    case SMI_STATUS_OBSOLETE:

	statStr = "obsolete";

	break;

    case SMI_STATUS_MANDATORY:

	statStr = "mandatory";

	break;

    case SMI_STATUS_OPTIONAL:

	statStr = "optional";

	break;

    case SMI_STATUS_UNKNOWN:

    default:

	statStr = "unknown";

	break;

    }

    return statStr;

}

static char* getStringAccess( SmiAccess smiAccess )

{

    switch( smiAccess ) {

    case SMI_ACCESS_NOT_IMPLEMENTED: return "not-implemented";

    case SMI_ACCESS_NOT_ACCESSIBLE : return "not-accessible";

    case SMI_ACCESS_NOTIFY         : return "notify";

    case SMI_ACCESS_READ_ONLY      : return "read-only";

    case SMI_ACCESS_READ_WRITE     : return "read-write";

    case SMI_ACCESS_UNKNOWN:

    default: return "unknown";

    }

}

#if 0

static char

*getStringValue(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_FLOAT32:

    case SMI_BASETYPE_FLOAT64:

    case SMI_BASETYPE_FLOAT128:

	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, "0x%*s", 2 * valuePtr->len, "");

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

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

                strncpy(&s[2+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)))) {

		if (n)

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

		n++;

		for (nn = smiGetFirstNamedNumber(typePtr); nn;

		     nn = smiGetNextNamedNumber(nn)) {

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

			break;

		}

		if (nn) {

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

		} else {

		    sprintf(s, "%d", i);

		}

	    }

	}

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

	break;

    case SMI_BASETYPE_UNKNOWN:

	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]);

	    }

	}

	break;

    }

    return s;

}

#endif /* 0 */

static int smiPow( int base, unsigned int exponent )

{

  unsigned int i;

  int ret = 1;

  if( exponent == 0 ) {

    return 1;

  }

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

    ret *= base;

  }

  return ret;

}

static void fprintSegment(FILE *f, int relindent, char *fmt, ...)

{

    va_list ap;

    va_start(ap, fmt);

    if ((ind == 0) || (ind + relindent == 0)) {

	ind += relindent;

    } else {

	if (relindent < 0) ind += relindent;

	fprintf(f, "%*c", ind * INDENT, ' ');

	if (relindent > 0) ind += relindent;

    }

    vfprintf(f, fmt, ap);

    va_end(ap);

}

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

{

    int i, j, len;

    fprintSegment(f, 0, "");

    if (s) {

	len = strlen(s);

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

	    for (j = 0; xmlEscapes[j].character; j++) {

		if (xmlEscapes[j].character == s[i]) break;

	    }

	    if (xmlEscapes[j].character) {

		fputs(xmlEscapes[j].escape, f);

	    } else {

		putc(s[i], f);

	    }

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

		fprintSegment(f, 0, "");

	    }

	}

    }

}

static void fprintDocumentation(FILE *f, const char *description)

{

    if (description) {

	fprintSegment(f, 1, "<xsd:documentation>\n");

	fprintMultilineString(f, description);

	fprintf(f, "\n");

	fprintSegment(f, -1, "</xsd:documentation>\n");

    }

}

static void fprintNamedNumber( FILE *f, SmiNamedNumber *nn )

{

    fprintSegment( f, 1, "<xsd:enumeration value=\"%s\">\n", nn->name );

    fprintSegment( f, 1, "<xsd:annotation>\n");

    fprintSegment( f, 1, "<xsd:appinfo>\n");

    fprintSegment( f, 0, "<intVal>%d</intVal>\n",

		   (int)nn->value.value.integer32 );

    fprintSegment( f, -1, "</xsd:appinfo>\n");

    fprintSegment( f, -1, "</xsd:annotation>\n");

    fprintSegment( f, -1, "</xsd:enumeration>\n");

}

static void fprintStdRestHead( FILE *f, SmiType *smiType )

{

    char *baseTypeName = getStringBasetype(smiType->basetype);

    char *prefix = getTypePrefix( baseTypeName );

    if( prefix ) {

	fprintSegment(f, 1, "<xsd:restriction base=\"%s:%s\">\n",

		      prefix, baseTypeName );

    }

    else {

	fprintSegment(f, 1, "<xsd:restriction base=\"%s\">\n", baseTypeName );

    }

}

static void fprintHexOrAsciiType( FILE *f, SmiType *parent,

				  SmiInteger32 minLength,

				  SmiInteger32 maxLength,

				  char *name, int hex )

{

    char *prefix = parent ? getTypePrefix( parent->name ) : NULL;

    char *typeFlag = hex ? "Hex" : "Ascii";

    if( name ) {

	fprintSegment( f, 1, "<xsd:simpleType name=\"%s%s\">\n",

		       name, typeFlag );

    } else {

	fprintSegment( f, 1, "<xsd:simpleType>\n");

    }

    if( prefix ) {

	fprintSegment( f, 1, "<xsd:restriction base=\"%s:%s%s\">\n",

		       prefix, parent->name, typeFlag );

    }

    else {

	fprintSegment( f, 1, "<xsd:restriction base=\"%s%s\">\n",

		       parent->name, typeFlag );

    }

    if( minLength > 0 ) {

	fprintSegment( f, 0, "<xsd:minLength value=\"%d\"/>\n",

		       (int)minLength );

    }

    if( maxLength > -1 ) {

	fprintSegment( f, 0, "<xsd:maxLength value=\"%d\"/>\n",

		       (int)maxLength );

    }

    fprintSegment( f, -1, "</xsd:restriction>\n");

    fprintSegment( f, -1, "</xsd:simpleType>\n");

}

static int dhInParent( SmiType *smiType )

{

    SmiType *parent = smiGetParentType( smiType );

    if( smiType->format && parent->format ) {

	return ! strcmp( smiType->format, parent->format );

    }

    return 0;

}

#define MD_DH_INT_NORMAL   1

#define MD_DH_INT_DECIMAL  2

#define MD_DH_INT_BIN      3

#define MD_DH_INT_OCT      4

#define MD_DH_INT_HEX      5

/* parse a (integer) display hint and specify the offset, if used */

static int getIntDHType( char *hint, int *offset )

{

    switch( hint[ 0 ] ) {

    case 'd':

	if( hint[1] ) {

	    *offset = 0;

	    *offset = atoi( &hint[2] );

	    return MD_DH_INT_DECIMAL;

	}

	return MD_DH_INT_NORMAL;

    case 'b':

	/* binary value */

	return MD_DH_INT_BIN;

    case 'o':

	/* octet value */

	return MD_DH_INT_OCT;

    case 'x':

	/* hex value */

	return MD_DH_INT_HEX;

    default:

	/* should not occur */

	return 0;

    }

}

static void fprintRestriction(FILE *f, SmiType *smiType)

{

    SmiRange *smiRange;

    /* print ranges etc. */

    switch( smiType->basetype ) {

    case SMI_BASETYPE_INTEGER32:

    {

	SmiInteger32 min = SMI_BASETYPE_INTEGER32_MIN;

	SmiInteger32 max = SMI_BASETYPE_INTEGER32_MAX;

	int offset = 0, useDecPoint = 0;

	if( smiType->format ) {

	  /* we have a display hint here, so check if we have to use

	     a decimal point */

	  useDecPoint =  

	    getIntDHType( smiType->format, &offset ) == MD_DH_INT_DECIMAL; 

	  /* xxx: other display hint types (binary, oct, hex) */

	}

	if( useDecPoint ) {

	  fprintSegment( f, 1, "<xsd:restriction base=\"xsd:decimal\">\n");

	  fprintSegment( f, 0, "<xsd:fractionDigits value=\"%d\"/>\n", offset );

	}

	else {

	  fprintStdRestHead( f, smiType );

	}

	smiRange = smiGetFirstRange( smiType );

	while( smiRange ) {

	    if( min == SMI_BASETYPE_INTEGER32_MIN ||

		smiRange->minValue.value.integer32 < min ) {

		min = smiRange->minValue.value.integer32;

	    }

	    if( max == SMI_BASETYPE_INTEGER32_MAX ||

		smiRange->maxValue.value.integer32 > max ) {

		max = smiRange->maxValue.value.integer32;

	    }

	    smiRange = smiGetNextRange( smiRange );

	}

	/* print minimu value */

	if( useDecPoint ) {

	    fprintSegment( f, 0, "<xsd:minInclusive value=\"%d.%d\"/>\n", 

			   (int)min / smiPow( 10, offset ), 

			   abs( (int)min % smiPow( 10, offset ) ) );

	} else {

	    fprintSegment( f, 0, "<xsd:minInclusive value=\"%d\"/>\n",

			   (int)min );

	}

	/* print maximum value */

	if( useDecPoint ) {

	    fprintSegment( f, 0, "<xsd:maxInclusive value=\"%d.%d\"/>\n", 

			   (int)max / smiPow( 10, offset ), 

			   abs( (int)max % smiPow( 10, offset ) ) );

	} else {

	    fprintSegment( f, 0, "<xsd:maxInclusive value=\"%d\"/>\n",

			   (int)max );

	}

	fprintSegment(f, -1, "</xsd:restriction>\n");

	break;

    }

    case SMI_BASETYPE_OCTETSTRING:

    {

	SmiInteger32  minLength, maxLength;

	unsigned int numSubRanges = 0;

	minLength = 0;

	maxLength = -1;

	/* get range details */

	for( smiRange = smiGetFirstRange( smiType );

	     smiRange;

	     smiRange = smiGetNextRange( smiRange ) ) {

	    if( minLength == 0 ||

		smiRange->minValue.value.integer32 < minLength ) {

		minLength = smiRange->minValue.value.integer32;	     

	    }

	    if( smiRange->maxValue.value.integer32 > maxLength ) {

		maxLength = smiRange->maxValue.value.integer32;

	    }

	    numSubRanges++;

	}

	if( smiType->format &&

	    ( smiType->decl == SMI_DECL_IMPLICIT_TYPE ||

	      smiType->decl == SMI_DECL_TEXTUALCONVENTION ) &&

	    ! dhInParent( smiType ) ) {

	    /*

	    fprintStringUnion( f, indent, smiType,

			       minLength, maxLength, 0, NULL );

	    */

	    char *pattern;

	    fprintSegment( f, 1, "<xsd:restriction base=\"xsd:string\">\n" );

	    /* create regexp */

	    pattern = smiFormatToPattern(smiType->format,

					 smiGetFirstRange(smiType));

	    if (pattern) {

		fprintSegment( f, 0, "<xsd:pattern value=\"%s\"/>\n", pattern);

		xfree(pattern);

	    }

	    else {

		fprintf( f, "

			 "This feature is not supported. -->\n" );

	    }

	    fprintSegment( f, -1, "</xsd:restriction>\n");

	}

	else {

	    SmiType *parent = smiGetParentType( smiType );

	    /*

	    fprintStringUnion( f, indent, smiType,

			       minLength, maxLength, secondTime,

			       smiType->name );

	    */

	    if( parent ) {

		if(  parent->format ) {

		    char *pattern;

		    pattern = smiFormatToPattern(parent->format,

						 smiGetFirstRange(smiType));

		    if (pattern) {

			fprintSegment( f, 1, "<xsd:restriction base=\"xsd:string\">\n" );

			fprintSegment(f, 0, "<xsd:pattern value=\"%s\"/>\n",

				      pattern);

			fprintSegment( f, -1, "</xsd:restriction>\n");

			xfree(pattern);

		    }

		}

		else if( smiType->name &&

			 ! strcmp( smiType->name, "IpAddress" ) ) {

		    SmiUnsigned32 lengths[] = {4, 4};

		    lengths[0] = 4; lengths[1] = 4;

		    fprintSegment( f, 1, "<xsd:restriction base=\"xsd:string\">\n" );

		    fprintSegment( f, 0, "

				   "value=\"(0|[1-9](([0-9]){0,2}))."

				   "(0|[1-9](([0-9]){0,2}))."

				   "(0|[1-9](([0-9]){0,2}))."

				   "(0|[1-9](([0-9]){0,2}))\"/>\n" );

		    fprintSegment( f, -1, "</xsd:restriction>\n");

		}

		else {

		    char *prefix = getTypePrefix( parent->name );

		    if( prefix ) {

			fprintSegment( f, 1, "<xsd:restriction base=\"%s:%s\">\n",

				       prefix, parent->name );

		    } else {

			fprintSegment( f, 1, "<xsd:restriction base=\"%s\">\n",

				       parent->name );

		    }

		    /* print length restriction */

		    if( minLength > 0 )

			fprintSegment( f, 0, "<xsd:minLength value=\"%d\"/>\n",

				       (int)minLength );

		    if( maxLength > -1 )

			fprintSegment( f, 0, "<xsd:maxLength value=\"%d\"/>\n",

				       (int)maxLength );		    

		    fprintSegment( f, -1, "</xsd:restriction>\n");

		}

	    }

	}

	break;

    }

    case SMI_BASETYPE_FLOAT128:

    {

/*	SmiFloat128 min, max; */

	fprintStdRestHead( f, smiType );

	/* xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_FLOAT64:

    {

/*	SmiFloat64 min,max;*/

	fprintStdRestHead( f, smiType );

	/* xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_FLOAT32:

    {

/*	SmiFloat32 min,max;*/

	fprintStdRestHead( f, smiType );

	/* xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_INTEGER64:

    {

/*	SmiInteger64 min,max;*/

	fprintStdRestHead( f, smiType );

	/* xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_UNSIGNED64:

    {

	SmiUnsigned64 min, max;

	min = SMI_BASETYPE_UNSIGNED64_MIN;

	max = SMI_BASETYPE_UNSIGNED64_MAX;

	fprintStdRestHead( f, smiType );

	smiRange = smiGetFirstRange( smiType );

	while( smiRange ) {

	    if( smiRange->minValue.value.unsigned64 < min ) {

		min = smiRange->minValue.value.unsigned64;

	    }

	    if( smiRange->maxValue.value.unsigned64 > max ) {

		max = smiRange->maxValue.value.unsigned64;

	    }

	    smiRange = smiGetNextRange( smiRange );

	}

	fprintSegment( f, 0, "<xsd:minInclusive value=\"%lu\"/>\n",

		       (unsigned long)min );

	fprintSegment( f, 0, "<xsd:maxInclusive value=\"%lu\"/>\n",

		       (unsigned long)max );

	fprintSegment(f, -1, "</xsd:restriction>\n");

	break;

    }

    case SMI_BASETYPE_UNSIGNED32:

    {

	SmiUnsigned32 min, max;

	min = 0;

	max = 4294967295UL;

	fprintStdRestHead( f, smiType );

	smiRange = smiGetFirstRange( smiType );

	while( smiRange ) {

	    if( smiRange->minValue.value.unsigned32 < min ) {

		min = smiRange->minValue.value.unsigned32;

	    }

	    if( smiRange->maxValue.value.unsigned32 > max ) {

		max = smiRange->maxValue.value.unsigned32;

	    }

	    smiRange = smiGetNextRange( smiRange );

	}

	fprintSegment( f, 0, "<xsd:minInclusive value=\"%u\"/>\n",

		       (unsigned int)min );

	fprintSegment( f, 0, "<xsd:maxInclusive value=\"%u\"/>\n",

		       (unsigned int)max );

	fprintSegment(f, -1, "</xsd:restriction>\n");

	break;

    }

    case SMI_BASETYPE_ENUM:

    case SMI_BASETYPE_BITS:

    {

	SmiNamedNumber *nn;

	fprintSegment(f, 1, "<xsd:restriction base=\"xsd:NMTOKEN\">\n");

	/* iterate named numbers */

	for( nn = smiGetFirstNamedNumber( smiType );

	     nn;

	     nn = smiGetNextNamedNumber( nn ) ) {

	    fprintNamedNumber( f, nn );

	}

	fprintSegment(f, -1, "</xsd:restriction>\n");

	break;

    }

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	fprintSegment( f, 0,

		       "<xsd:restriction base=\"smi:ObjectIdentifier\"/>\n");

	break;

    case SMI_BASETYPE_UNKNOWN:

	/* should not occur */

	break;

    case SMI_BASETYPE_POINTER:

	/* TODO */

	break;

    }

}

static unsigned int getNamedNumberCount( SmiType *smiType )

{

    SmiNamedNumber *nn;

    unsigned int ret = 0;

    for( nn = smiGetFirstNamedNumber( smiType );

	 nn;

	 nn = smiGetNextNamedNumber( nn ) ) {

	ret++;

    }

    return ret;

}

static void fprintBitList( FILE *f, SmiType *smiType )

{

    fprintSegment( f, 1, "<xsd:restriction>\n" );

    fprintSegment( f, 1, "<xsd:simpleType>\n" );

    fprintSegment( f, 1, "<xsd:list>\n" );  

    fprintSegment( f, 1, "<xsd:simpleType>\n" );

    fprintRestriction( f, smiType );

    fprintSegment( f, -1, "</xsd:simpleType>\n" );

    fprintSegment( f, -1, "</xsd:list>\n" );

    fprintSegment( f, -1, "</xsd:simpleType>\n");

    fprintSegment( f, 0, "<xsd:maxLength value=\"%d\"/>\n",

		   getNamedNumberCount( smiType ) );

    fprintSegment( f, -1, "</xsd:restriction>\n");

}

static int getNumSubRanges( SmiType *smiType )

{

    SmiRange *smiRange;

    int num = 0;

    for( smiRange = smiGetFirstRange( smiType );

	 smiRange;

	 smiRange = smiGetNextRange( smiRange ) ) {

	num++;

    }

    return num;

}

static void fprintSubRangeType( FILE *f,

				SmiRange *smiRange, SmiType *smiType )

{

    switch( smiType->basetype ) {

    case SMI_BASETYPE_UNSIGNED32: {

	SmiUnsigned32 min, max;

	min = 0;

	max = 4294967295UL;

	if( smiRange->minValue.value.unsigned32 < min ) {

	    min = smiRange->minValue.value.unsigned32;

	}

	if( smiRange->maxValue.value.unsigned32 > max ) {

	    max = smiRange->maxValue.value.unsigned32;

	}

	fprintSegment( f, 1, "<xsd:simpleType>\n");

	fprintStdRestHead( f, smiType );

	fprintSegment( f, 0, "<xsd:minInclusive value=\"%u\"/>\n",

		       (unsigned int)min );

	fprintSegment( f, 0, "<xsd:maxInclusive value=\"%u\"/>\n",

		       (unsigned int)max );

	fprintSegment(f, -1, "</xsd:restriction>\n");

	fprintSegment(f, -1, "</xsd:simpleType>\n");

	break;

    }

    case SMI_BASETYPE_INTEGER32: {

	SmiInteger32 min, max;

	min = SMI_BASETYPE_INTEGER32_MIN;

	max = SMI_BASETYPE_INTEGER32_MAX;

	if( min == SMI_BASETYPE_INTEGER32_MIN ||

	    smiRange->minValue.value.integer32 < min ) {

	    min = smiRange->minValue.value.integer32;

	}

	if( max == SMI_BASETYPE_INTEGER32_MAX ||

	    smiRange->maxValue.value.integer32 > max ) {

	    max = smiRange->maxValue.value.integer32;

	}

	fprintSegment( f, 1, "<xsd:simpleType>\n");

    	fprintStdRestHead( f, smiType );

	fprintSegment( f, 0, "<xsd:minInclusive value=\"%d\"/>\n", (int)min );

	fprintSegment( f, 0, "<xsd:maxInclusive value=\"%d\"/>\n", (int)max );

	fprintSegment(f, -1, "</xsd:restriction>\n");	

	fprintSegment(f, -1, "</xsd:simpleType>\n");

	break;

    }

    case SMI_BASETYPE_OCTETSTRING: {

	SmiInteger32  minLength, maxLength;

	minLength = 0;

	maxLength = -1;

	if( smiRange->minValue.value.integer32 < minLength ) {

	    minLength = smiRange->minValue.value.integer32;	     

	}

	if( smiRange->maxValue.value.integer32 > maxLength ) {

	    maxLength = smiRange->maxValue.value.integer32;

	}

	fprintHexOrAsciiType( f, smiType,

			      minLength, maxLength, NULL, 1 );

	break;

    }

    case SMI_BASETYPE_FLOAT128:

    {

/*	SmiFloat128 min, max; 

	xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_FLOAT64:

    {

/*	SmiFloat64 min,max;

	xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_FLOAT32:

    {

/*	SmiFloat32 min,max;

	xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_INTEGER64:

    {

/*	SmiInteger64 min,max;

	 xxx, only SMIng */

	break;

    }

    case SMI_BASETYPE_UNSIGNED64:

    {

	SmiUnsigned64 min, max;

	min = SMI_BASETYPE_UNSIGNED64_MIN;

	max = SMI_BASETYPE_UNSIGNED64_MAX;

	if( smiRange->minValue.value.unsigned64 < min ) {

	    min = smiRange->minValue.value.unsigned64;

	}

	if( smiRange->maxValue.value.unsigned32 > max ) {

	    max = smiRange->maxValue.value.unsigned64;

	}

	fprintSegment( f, 1, "<xsd:simpleType>\n");

	fprintStdRestHead( f, smiType );