/*

 * check.c --

 *

 *      This module contains semantics checks that are shared between

 *	the SMI parser backends.

 *

 * Copyright (c) 2000 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.

 *

 * @(#) $Id: check.c 7640 2008-01-31 15:29:52Z schoenw $

 */

#include <config.h>

#include <string.h>

#include <errno.h>

#include <ctype.h>

#include <sys/types.h>

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "error.h"

#include "util.h"

#include "data.h"

#include "check.h"

#include "smi.h"

#ifdef HAVE_DMALLOC_H

#include <dmalloc.h>

#endif

/*

 *----------------------------------------------------------------------

 *

 * compareValues --

 *

 *	Compare two SmiValues a and b.

 *

 * Results:

 *      <= -2   if a is less than b-1

 *      -1      if a is b-1

 *      0       if equal

 *      1       if a is b+1

 *      >= 2    if a is greater than b+1

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

static int

compareValues(SmiValue *a, SmiValue *b) {

    if ((a->basetype == SMI_BASETYPE_UNSIGNED32) &&

	(b->basetype == SMI_BASETYPE_UNSIGNED32)) {

	if (a->value.unsigned32 == b->value.unsigned32) {

	    return 0;

	} else {

	    if (a->value.unsigned32 > b->value.unsigned32) {

		if (a->value.unsigned32 == b->value.unsigned32 + 1) {

		    return 1;

		} else {

		    return 2;

		}

	    } else if (a->value.unsigned32 < b->value.unsigned32) {

		if (a->value.unsigned32 + 1 == b->value.unsigned32) {

		    return -1;

		} else {

		    return -2;

		}

	    }

	}

    }

    if ((a->basetype == SMI_BASETYPE_INTEGER32) &&

	(b->basetype == SMI_BASETYPE_INTEGER32)) {

	if (a->value.integer32 == b->value.integer32) {

	    return 0;

	} else {

	    if (a->value.integer32 > b->value.integer32) {

		if (a->value.integer32 == b->value.integer32 + 1) {

		    return 1;

		} else {

		    return 2;

		}

	    } else if (a->value.integer32 < b->value.integer32) {

		if (a->value.integer32 + 1 == b->value.integer32) {

		    return -1;

		} else {

		    return -2;

		}

	    }

	}

    }

    if ((a->basetype == SMI_BASETYPE_UNSIGNED32) &&

	(b->basetype == SMI_BASETYPE_INTEGER32)) {

	if ((b->value.integer32 < -1) ||

	    ((a->value.unsigned32 > 1) &&

	     (a->value.unsigned32-1 > 2147483647))) {

	    return 2;

	}

	return a->value.unsigned32 - b->value.integer32;

    }

    if ((a->basetype == SMI_BASETYPE_INTEGER32) &&

	(b->basetype == SMI_BASETYPE_UNSIGNED32)) {

	if ((a->value.integer32 < -1) ||

	    ((b->value.unsigned32 > 1) &&

	     (b->value.unsigned32-1 > 2147483647))) {

	    return -2;

	}

	return b->value.unsigned32 - a->value.integer32;

    }

    return 0;

}

/*

 *----------------------------------------------------------------------

 *

 * redefinition --

 *

 *	Print out error messages about a (case) redefinition.

 *

 * Results:

 *	None.

 *

 * Side effects:

 *	None.

 *

 *----------------------------------------------------------------------

 */

static void

redefinition(Parser *parser, int line1, char *name1, Module *module,

	     int line2, char *name2)

{

    char *tmp = parser->path;

    int equal = (strcmp(name1, name2) == 0);

    if (!strcmp(name1, "IpAddress") ||

	!strcmp(name1, "TimeTicks") ||

	!strcmp(name1, "Opaque") ||

	!strcmp(name1, "Integer32") ||

	!strcmp(name1, "Unsigned32") ||

	!strcmp(name1, "Counter32") ||

	!strcmp(name1, "Gauge32") ||

	!strcmp(name1, "Counter64") ||

	!strcmp(name1, "Integer64") ||

	!strcmp(name1, "Unsigned64")) {

	if (line1) {

	    smiPrintErrorAtLine(parser, ERR_BASETYPE_REDEFINITION, line1, name1);

	} else {

	    smiPrintError(parser, ERR_BASETYPE_REDEFINITION, name1);

	}

    } else {

	if (! module) {

	    if (equal) {

		if (line1) {

		    smiPrintErrorAtLine(parser, ERR_REDEFINITION, line1, name1);

		} else {

		    smiPrintError(parser, ERR_REDEFINITION, name1);

		}

	    } else {

		if (line1) {

		    smiPrintErrorAtLine(parser, ERR_CASE_REDEFINITION,

					line1, name1, name2);

		} else {

		    smiPrintError(parser, ERR_CASE_REDEFINITION, name1, name2);

		}

	    }

	} else {

	    if (equal) {

		if (line1) {

		    smiPrintErrorAtLine(parser, ERR_EXT_REDEFINITION, line1,

					module->export.name, name1);

		} else {

		    smiPrintError(parser, ERR_EXT_REDEFINITION,

				  module->export.name, name1);

		}

	    } else {

		if (line1) {

		    smiPrintErrorAtLine(parser, ERR_EXT_CASE_REDEFINITION, line1,

					name1, module->export.name, name2);

		} else {

		    smiPrintError(parser, ERR_EXT_CASE_REDEFINITION,

				  name1, module->export.name, name2);

		}

	    }

	    parser->path = module->export.path;

	}

	smiPrintErrorAtLine(parser, ERR_PREVIOUS_DEFINITION, line2, name2);

	if (module) {

	    parser->path = tmp;

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckObjectName --

 *

 *      Check whether a given object name already exists

 *	in a given module.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

smiCheckObjectName(Parser *parser, Module *module, char *name)

{

    Object	*objectPtr;

    Type        *typePtr;

    Module	*modPtr;

    int errRedef = smiGetErrorSeverity(ERR_REDEFINITION);

    int errExtRedef = smiGetErrorSeverity(ERR_EXT_REDEFINITION);

    int errCaseRedef = smiGetErrorSeverity(ERR_CASE_REDEFINITION);

    int errExtCaseRedef = smiGetErrorSeverity(ERR_EXT_CASE_REDEFINITION);

    if (! (parser->flags & SMI_FLAG_ERRORS)

	|| (errRedef > smiHandle->errorLevel

	    && errExtRedef > smiHandle->errorLevel

	    && errCaseRedef > smiHandle->errorLevel

	    && errExtCaseRedef > smiHandle->errorLevel)) {

	return;

    }

    /*

     * This would really benefit from having a hash table...

     */

    for (modPtr = smiHandle->firstModulePtr;

	 modPtr; modPtr = modPtr->nextPtr) {

	/*

	 * Skip all external modules if we are not interested in

	 * generating warning on extern redefinitions.

	 */

	if (errExtRedef > smiHandle->errorLevel

	    && errExtCaseRedef > smiHandle->errorLevel

	    && modPtr != module) {

	    continue;

	}

        for (objectPtr = modPtr->firstObjectPtr;

	     objectPtr; objectPtr = objectPtr->nextPtr) {

	    if (! (objectPtr->flags & FLAG_INCOMPLETE)

		&& ! strcasecmp(name, objectPtr->export.name)) {

		redefinition(parser, 0, name,

			     modPtr == module ? NULL : objectPtr->modulePtr,

			     objectPtr->line, objectPtr->export.name);

	    }

	}

	for (typePtr = modPtr->firstTypePtr;

	     typePtr; typePtr = typePtr->nextPtr) {

	    /* TODO: must ignore SEQUENCE types here ... */

	    if (! (typePtr->flags & FLAG_INCOMPLETE)

		&& typePtr->export.name

		&& !strcasecmp(name, typePtr->export.name)) {

		redefinition(parser, 0, name,

			     modPtr == module ? NULL : typePtr->modulePtr,

			     typePtr->line, typePtr->export.name);

	    }

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckTypeName --

 *

 *      Check whether a given type name already exists

 *	in a given module.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

smiCheckTypeName(Parser *parser, Module *module, char *name, int line)

{

    Object	*objectPtr;

    Type        *typePtr;

    Module	*modPtr;

    int errRedef = smiGetErrorSeverity(ERR_REDEFINITION);

    int errExtRedef = smiGetErrorSeverity(ERR_EXT_REDEFINITION);

    int errCaseRedef = smiGetErrorSeverity(ERR_CASE_REDEFINITION);

    int errExtCaseRedef = smiGetErrorSeverity(ERR_EXT_CASE_REDEFINITION);

    if (! (parser->flags & SMI_FLAG_ERRORS)

	|| (errRedef > smiHandle->errorLevel

	    && errExtRedef > smiHandle->errorLevel

	    && errCaseRedef > smiHandle->errorLevel

	    && errExtCaseRedef > smiHandle->errorLevel)) {

	return;

    }

    /*

     * This would really benefit from having a hash table...

     */

    for (modPtr = smiHandle->firstModulePtr;

	 modPtr; modPtr = modPtr->nextPtr) {

	/*

	 * Skip all external modules if we are not interested in

	 * generating warning on extern redefinitions.

	 */

	if (errExtRedef > smiHandle->errorLevel

	    && errExtCaseRedef > smiHandle->errorLevel

	    && modPtr != module) {

	    continue;

	}

	for (typePtr = modPtr->firstTypePtr;

	     typePtr; typePtr = typePtr->nextPtr) {

	    /* TODO: must ignore SEQUENCE types here ... */

	    if (! (typePtr->flags & FLAG_INCOMPLETE)

		&& typePtr->export.name

		&& !strcasecmp(name, typePtr->export.name)) {

		redefinition(parser, line, name,

			     modPtr == module ? NULL : typePtr->modulePtr,

			     typePtr->line, typePtr->export.name);

	    }

	}

        for (objectPtr = modPtr->firstObjectPtr;

	     objectPtr; objectPtr = objectPtr->nextPtr) {

	    if (! (objectPtr->flags & FLAG_INCOMPLETE)

		&& ! strcasecmp(name, objectPtr->export.name)) {

		redefinition(parser, line, name,

			     modPtr == module ? NULL : objectPtr->modulePtr,

			     objectPtr->line, objectPtr->export.name);

	    }

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckFormat --

 *

 *      Check whether a format specification is valid.

 *

 * Results:

 *      Returns 1 of the format is acceptable and 0 otherwise.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

int

smiCheckFormat(Parser *parser, SmiBasetype basetype, char *format, int line)

{

    int n, repeat, error = 1;

    char *p = format;

    switch (basetype) {

    case SMI_BASETYPE_INTEGER32:

    case SMI_BASETYPE_INTEGER64:

    case SMI_BASETYPE_UNSIGNED32:

    case SMI_BASETYPE_UNSIGNED64:

	if (*p == 'x' || *p == 'o' || *p == 'b') {

	    p++;

	    error = (*p != 0);

	} else if (*p == 'd') {

	    p++;

	    if (! *p) {

		error = 0;

		break;

	    }

	    if (*p != '-') {

		error = 0;

		break;

	    }

	    for (n = 0, p++; *p && isdigit((int) *p); p++, n++) ;

	    error = (*p != 0 || n <= 0);

	}

	break;

    case SMI_BASETYPE_OCTETSTRING:

	while (*p) {

	    if ((repeat = (*p == '*'))) p++;                /* part 1 */

	    for (n = 0; *p && isdigit((int) *p); p++, n++) ;/* part 2 */

	    if (! *p || n == 0) {

		break;

	    }

	    if (*p != 'x' && *p != 'd' && *p != 'o'         /* part 3 */

		&& *p != 'a' && *p != 't') {

		break;

	    }

	    p++;

	    if (*p                                          /* part 4 */

		&& ! isdigit((int) *p) && *p != '*') p++;

	    if (repeat && *p                                /* part 5 */

		&& ! isdigit((int) *p) && *p != '*') p++;

	}

	error = *p;

	break;

    default:

	break;

    }

    if (error) {

	if (line) {

	    smiPrintErrorAtLine(parser, ERR_INVALID_FORMAT, line, format);

	} else {

	    smiPrintError(parser, ERR_INVALID_FORMAT, format);

	}

    }

    return ! error;

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckNamedNumberRedefinition --

 *

 *      Check whether named numbers redefine names or numbers.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

smiCheckNamedNumberRedefinition(Parser *parser, Type *type)

{

    List *list1Ptr, *list2Ptr;

    NamedNumber *nn1Ptr, *nn2Ptr;

    if (! type || (type->export.basetype != SMI_BASETYPE_ENUM

		      && type->export.basetype != SMI_BASETYPE_BITS)) {

	return;

    }

    for (list1Ptr = type->listPtr;

	 list1Ptr; list1Ptr = list1Ptr->nextPtr) {

	nn1Ptr = (NamedNumber *)(list1Ptr->ptr);

	for (list2Ptr = list1Ptr->nextPtr;

	     list2Ptr; list2Ptr = list2Ptr->nextPtr) {

	    nn2Ptr = (NamedNumber *)(list2Ptr->ptr);

	    if (type->export.basetype == SMI_BASETYPE_ENUM) {

		if (!strcmp(nn1Ptr->export.name, nn2Ptr->export.name)) {

		    smiPrintErrorAtLine(parser, ERR_ENUM_NAME_REDEFINITION,

					type->line,

					nn1Ptr->export.name);

		}

		if (nn1Ptr->export.value.value.integer32

		    == nn2Ptr->export.value.value.integer32) {

		    smiPrintErrorAtLine(parser, ERR_ENUM_NUMBER_REDEFINITION,

					type->line,

					nn1Ptr->export.value.value.integer32);

		}

	    }

	    if (type->export.basetype == SMI_BASETYPE_BITS) {

		if (!strcmp(nn1Ptr->export.name, nn2Ptr->export.name)) {

		    smiPrintErrorAtLine(parser, ERR_BITS_NAME_REDEFINITION,

					type->line,

					nn1Ptr->export.name);

		}

		if (nn1Ptr->export.value.value.unsigned32

		    == nn2Ptr->export.value.value.unsigned32) {

		    smiPrintErrorAtLine(parser, ERR_BITS_NUMBER_REDEFINITION,

					type->line,

					nn1Ptr->export.value.value.unsigned32);

		}

	    }

	}

    }   

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckNamedNumberSubtyping --

 *

 *      Check whether named numbers in a derived type are compatible

 *	with the named numbers in the parent type.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

smiCheckNamedNumberSubtyping(Parser *parser, Type *type)

{

    List *list1Ptr, *list2Ptr;

    NamedNumber *nn1Ptr, *nn2Ptr;

    if (! type || ! type->parentPtr || ! type->parentPtr->parentPtr

	|| (type->export.basetype != SMI_BASETYPE_ENUM

	    && type->export.basetype != SMI_BASETYPE_BITS)) {

	return;

    }

    for (list1Ptr = type->listPtr;

	 list1Ptr; list1Ptr = list1Ptr->nextPtr) {

	nn1Ptr = (NamedNumber *)(list1Ptr->ptr);

	for (list2Ptr = type->parentPtr->listPtr;

	     list2Ptr; list2Ptr = list2Ptr->nextPtr) {

	    nn2Ptr = (NamedNumber *)(list2Ptr->ptr);

	    if (type->export.basetype == SMI_BASETYPE_ENUM) {

		if (! strcmp(nn1Ptr->export.name, nn2Ptr->export.name)

		    && nn1Ptr->export.value.value.integer32

		    == nn2Ptr->export.value.value.integer32) {

		    break;

		}

	    }

	    if (type->export.basetype == SMI_BASETYPE_BITS) {

		if (! strcmp(nn1Ptr->export.name, nn2Ptr->export.name)

		    && nn1Ptr->export.value.value.unsigned32

		    == nn2Ptr->export.value.value.unsigned32) {

		    break;

		}

	    }

	}

	if (! list2Ptr) {

	    if (type->export.basetype == SMI_BASETYPE_ENUM) {

		if (type->parentPtr->export.name) {

		    smiPrintErrorAtLine(parser, ERR_ENUM_SUBTYPE_OF,

					type->line,

					nn1Ptr->export.name,

					nn1Ptr->export.value.value.integer32,

					type->parentPtr->export.name);

		} else {

		    smiPrintErrorAtLine(parser, ERR_ENUM_SUBTYPE,

					type->line,

					nn1Ptr->export.name,

					nn1Ptr->export.value.value.integer32);

		}

	    }

	    if (type->export.basetype == SMI_BASETYPE_BITS) {

		if (type->parentPtr->export.name) {

		    smiPrintErrorAtLine(parser, ERR_BITS_SUBTYPE_OF,

					type->line,

					nn1Ptr->export.name,

					type->parentPtr->export.name);

		} else {

		    smiPrintErrorAtLine(parser, ERR_BITS_SUBTYPE,

					type->line,

					nn1Ptr->export.name);

		}

	    }

	}

    }

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckNamedNumbersOrder --

 *

 *      Check and normalize the order of named numbers in a bits

 *	or enumeration type.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

smiCheckNamedNumbersOrder(Parser *parser, Type *type)

{

    List *listPtr, *lastPtr, *nextPtr, *ptr;

    NamedNumber *nnPtr;

    int shutup = 0;

    if (! type || ! type->parentPtr

	|| (type->export.basetype != SMI_BASETYPE_ENUM

	    && type->export.basetype != SMI_BASETYPE_BITS)) {

	return;

    }

    /* Check whether the first bit has been given a name. */

    if (type->export.basetype == SMI_BASETYPE_BITS) {

	for (listPtr = type->listPtr; listPtr; listPtr = listPtr->nextPtr) {

	    nnPtr = (NamedNumber *)(listPtr->ptr);

	    if (nnPtr->export.value.value.unsigned32 == 0) break;

	}

	if (! listPtr) {

	    smiPrintErrorAtLine(parser, ERR_BITS_ZERO_NOT_NAMED, type->line);

	}

    }

    lastPtr = NULL;

    for (listPtr = type->listPtr; listPtr; listPtr = nextPtr) {

	nextPtr = listPtr->nextPtr;

	nnPtr = (NamedNumber *)(listPtr->ptr);

	if (lastPtr) {

	    if ((type->export.basetype == SMI_BASETYPE_ENUM) &&

		(((NamedNumber *)(listPtr->ptr))->export.value.value.integer32 <=

		 ((NamedNumber *)(lastPtr->ptr))->export.value.value.integer32)) {

		if (!shutup) {

		    smiPrintErrorAtLine(parser, ERR_NAMED_NUMBERS_NOT_ASCENDING,

					type->line,

					type->export.name);

		    shutup = 1;

		}

		/* remove listPtr from the list */

		lastPtr->nextPtr = listPtr->nextPtr;

		/* re-insert listPtr at the right position */

		if (((NamedNumber *)(type->listPtr->ptr))->export.value.value.integer32 > ((NamedNumber *)(listPtr->ptr))->export.value.value.integer32) {

		    listPtr->nextPtr = type->listPtr;

		    type->listPtr = listPtr;

		} else {

		    for (ptr = type->listPtr; ptr; ptr = ptr->nextPtr) {

			if ((!ptr->nextPtr) ||

			    (((NamedNumber *)(ptr->nextPtr->ptr))->export.value.value.integer32 >= ((NamedNumber *)(listPtr->ptr))->export.value.value.integer32)) {

			    listPtr->nextPtr = ptr->nextPtr;

			    ptr->nextPtr = listPtr;

			    break;

			}

		    }

		}

		/* set lastPtr to the last processed item */

		for (lastPtr = listPtr; lastPtr->nextPtr != nextPtr;

		     lastPtr = lastPtr->nextPtr);

		continue;

	    }

	    if ((type->export.basetype == SMI_BASETYPE_BITS) &&

		(((NamedNumber *)(listPtr->ptr))->export.value.value.unsigned32 <=

		 ((NamedNumber *)(lastPtr->ptr))->export.value.value.unsigned32)) {

		if (!shutup) {

		    smiPrintErrorAtLine(parser, ERR_NAMED_NUMBERS_NOT_ASCENDING,

					type->line,

					type->export.name);

		    shutup = 1;

		}

		/* remove listPtr from the list */

		lastPtr->nextPtr = listPtr->nextPtr;

		/* re-insert listPtr at the right position */

		if (((NamedNumber *)(type->listPtr->ptr))->export.value.value.unsigned32 > ((NamedNumber *)(listPtr->ptr))->export.value.value.unsigned32) {

		    listPtr->nextPtr = type->listPtr;

		    type->listPtr = listPtr;

		} else {

		    for (ptr = type->listPtr; ptr; ptr = ptr->nextPtr) {

			if ((!ptr->nextPtr) ||

			    (((NamedNumber *)(ptr->nextPtr->ptr))->export.value.value.unsigned32 > ((NamedNumber *)(listPtr->ptr))->export.value.value.unsigned32)) {

			    listPtr->nextPtr = ptr->nextPtr;

			    ptr->nextPtr = listPtr;

			    break;

			}

		    }

		}

		/* set lastPtr to the last processed item */

		for (lastPtr = listPtr; lastPtr->nextPtr != nextPtr;

		     lastPtr = lastPtr->nextPtr);

		continue;

	    }

	}

	lastPtr = listPtr;

    }

}

/*

 *----------------------------------------------------------------------

 *

 * smiCheckIndex --

 *

 *      Check whether an index conforms to the SMI restrictions.

 *

 * Results:

 *      None.

 *

 * Side effects:

 *      None.

 *

 *----------------------------------------------------------------------

 */

void

smiCheckIndex(Parser *parser, Object *object)

{

    List *listPtr, *list2Ptr;

    Object *indexPtr;

    Type *typePtr, *rTypePtr;

    Range *rangePtr;

    NamedNumber *nnPtr;

    Node *nodePtr;

    int minSize, maxSize, len = 0;

    int aux = 0, cols = 0, acc = 0;

    for (nodePtr = object->nodePtr->firstChildPtr, cols = 0;

	 nodePtr; nodePtr = nodePtr->nextPtr) {

	cols++;

    }

    for (listPtr = object->listPtr; listPtr; listPtr = listPtr->nextPtr) {

	indexPtr = (Object *) listPtr->ptr;

	typePtr = indexPtr->typePtr;

	/* checkObjects() already handles unknown objects */

	if (indexPtr->export.nodekind != SMI_NODEKIND_COLUMN &&

	    ((indexPtr->flags & FLAG_INCOMPLETE) == 0)) {

	    smiPrintErrorAtLine(parser, ERR_INDEX_NOT_COLUMN,

				indexPtr->line,

				indexPtr->export.name,

				object->export.name);

	}

	if (!typePtr)

	    continue;

	switch (typePtr->export.basetype) {

	case SMI_BASETYPE_INTEGER32:

	    for (rTypePtr = typePtr; rTypePtr && ! rTypePtr->listPtr;

 		 rTypePtr = rTypePtr->parentPtr) {

	    }

	    if (! rTypePtr) {

		if (object->modulePtr != indexPtr->modulePtr) {

		    smiPrintErrorAtLine(parser, ERR_INDEX_NO_RANGE_MOD,

					object->line,

					indexPtr->modulePtr->export.name,

					indexPtr->export.name,

					object->export.name);

		} else {

		    smiPrintErrorAtLine(parser, ERR_INDEX_NO_RANGE,

					indexPtr->line,

					indexPtr->export.name,

					object->export.name);

		}

	    } else {

		for (list2Ptr = rTypePtr->listPtr;

		     list2Ptr; list2Ptr = list2Ptr->nextPtr) {

		    rangePtr = (Range *) list2Ptr->ptr;

		    if (rangePtr->export.maxValue.value.integer32 < 0) {

			smiPrintErrorAtLine(parser, ERR_INDEX_RANGE_NEGATIVE,

					    indexPtr->line,

					    indexPtr->export.name,

					    object->export.name);

			break;

		    }

		}

	    }

	    len++;

	    break;

	case SMI_BASETYPE_OCTETSTRING:

	    /* TODO: We need to check ranges of parent types as well

	       if this type does not have a range restriction. */

	    for (rTypePtr = typePtr; rTypePtr && ! rTypePtr->listPtr;

		 rTypePtr = rTypePtr->parentPtr) {

	    }

	    minSize = 65535;

	    maxSize = -1;

	    if (! rTypePtr) {

		if (object->modulePtr != indexPtr->modulePtr) {

		    smiPrintErrorAtLine(parser, ERR_INDEX_STRING_NO_SIZE_MOD,

					object->line,

					indexPtr->modulePtr->export.name,

					indexPtr->export.name,

					object->export.name);

		} else {

		    smiPrintErrorAtLine(parser, ERR_INDEX_STRING_NO_SIZE,

					indexPtr->line,

					indexPtr->export.name,

					object->export.name);

		}

		minSize = 0;

		maxSize = 65535;

	    } else {

	        for (list2Ptr = rTypePtr->listPtr;

		     list2Ptr; list2Ptr = list2Ptr->nextPtr) {

		    rangePtr = (Range *) list2Ptr->ptr;

		    if (rangePtr->export.minValue.value.integer32 < minSize) {

			minSize = rangePtr->export.minValue.value.integer32;

		    }

		    if (rangePtr->export.maxValue.value.integer32 > maxSize) {

			maxSize = rangePtr->export.maxValue.value.integer32;

		    }

		}

		if (minSize == 65535) {

		    minSize = 0;

		}

		if (maxSize < 0) {

		    maxSize = 65535;

		}

	    }

	    len += maxSize;

	    if (minSize != maxSize) {

		if (! (object->export.implied && (! listPtr->nextPtr))) {

		    len++;

		}

	    }

	    break;

	case SMI_BASETYPE_OBJECTIDENTIFIER:

	    if (object->modulePtr != indexPtr->modulePtr) {

		smiPrintErrorAtLine(parser, ERR_INDEX_OID_NO_SIZE_MOD,

				    object->line,

				    indexPtr->modulePtr->export.name,

				    indexPtr->export.name,

				    object->export.name);

	    } else {

		smiPrintErrorAtLine(parser, ERR_INDEX_OID_NO_SIZE,

				    indexPtr->line,

				    indexPtr->export.name,

				    object->export.name);

	    }

	    len += 128;

	    if (!indexPtr->export.implied) {

		len++;

	    }

	    break;

	case SMI_BASETYPE_UNSIGNED32:

	    len++;