/*

 * smidiff.c --

 *

 *      Compute and check differences between MIB modules.

 *

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

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

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

 * Copyright (c) 2006 J. Schoenwaelder, International University Bremen.

 *

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

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

 *

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

 */

/*

 * TODO:

 *

 * - replacing an implicit type with a named type should cause a real

 *   error if the new type is formally not identical (Mike Heard)

 */

#include <config.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <stdarg.h>

#include <ctype.h>

#ifdef HAVE_WIN_H

#include "win.h"

#endif

#include "smi.h"

#include "shhopt.h"

static int errorLevel = 6;	/* smidiff/libsmi error level (inclusive) */

static int mFlag = 0;		/* show the name for error messages */

static int sFlag = 0;		/* show the severity for error messages */

static char *oldCompl = NULL;	/* name of old compliance statement */

static char *newCompl = NULL;	/* name of new compliance statement */

/* the `:' separates the view identifier */

static const char *oldTag = "smidiff:old";

static const char *newTag = "smidiff:new";

#define CODE_SHOW_PREVIOUS		0x01

#define CODE_SHOW_PREVIOUS_IMPLICIT	0x02

typedef struct Error {

    int level;		/* error level - roughly the same as smilint */

    int id;		/* error id used in the error() invocation */

    char *tag;		/* tag for error identification on cmd line */

    char *fmt;		/* the complete error format string */

    char *description;	/* description of the error message */

} Error;

#define ERR_INTERNAL				0

#define ERR_TYPE_REMOVED			1

#define ERR_TYPE_ADDED				2

#define ERR_NODE_REMOVED			3

#define ERR_NODE_ADDED				4

#define ERR_BASETYPE_CHANGED			5

#define ERR_DECL_CHANGED			6

#define ERR_LEGAL_STATUS_CHANGED		8

#define ERR_PREVIOUS_DEFINITION			9

#define ERR_STATUS_CHANGED			10

#define ERR_DESCR_ADDED				11

#define ERR_DESCR_REMOVED			12

#define ERR_DESCR_CHANGED			13

#define ERR_REF_ADDED				14

#define ERR_REF_REMOVED				15

#define ERR_REF_CHANGED				16

#define ERR_FORMAT_ADDED			17

#define ERR_FORMAT_REMOVED			18

#define ERR_FORMAT_CHANGED			19

#define ERR_UNITS_ADDED				20

#define ERR_UNITS_REMOVED			21

#define ERR_UNITS_CHANGED			22

#define ERR_ACCESS_ADDED			23

#define ERR_ACCESS_REMOVED			24

#define ERR_ACCESS_CHANGED			25

#define ERR_NAME_ADDED				26

#define ERR_NAME_REMOVED			27

#define ERR_NAME_CHANGED			28

#define ERR_TO_IMPLICIT				29

#define ERR_FROM_IMPLICIT			30

#define ERR_RANGE_ADDED				31

#define ERR_RANGE_REMOVED			32

#define ERR_RANGE_CHANGED			33

#define ERR_DEFVAL_ADDED			34

#define ERR_DEFVAL_REMOVED			35

#define ERR_DEFVAL_CHANGED			36

#define ERR_ORGA_ADDED				37

#define ERR_ORGA_REMOVED			38

#define ERR_ORGA_CHANGED			39

#define ERR_CONTACT_ADDED			40

#define ERR_CONTACT_REMOVED			41

#define ERR_CONTACT_CHANGED			42

#define ERR_SMIVERSION_CHANGED			43

#define ERR_REVISION_ADDED			44

#define ERR_REVISION_REMOVED			45

#define ERR_REVISION_CHANGED			46

#define ERR_LENGTH_CHANGED			47

#define ERR_LENGTH_OF_TYPE_CHANGED		48

#define ERR_LENGTH_ADDED			49

#define ERR_MEMBER_ADDED			50

#define ERR_MEMBER_REMOVED			51

#define ERR_MEMBER_CHANGED			52

#define ERR_OBJECT_ADDED			53

#define ERR_OBJECT_REMOVED			54

#define ERR_OBJECT_CHANGED			55

#define ERR_NAMED_NUMBER_ADDED			56

#define ERR_NAMED_NUMBER_REMOVED		57

#define ERR_NAMED_NUMBER_CHANGED		58

#define ERR_NAMED_BIT_ADDED_OLD_BYTE		59

#define ERR_NODEKIND_CHANGED			60

#define ERR_INDEXKIND_CHANGED			61

#define ERR_INDEX_CHANGED			62

#define ERR_TYPE_IS_AND_WAS			63

#define ERR_RANGE_OF_TYPE_CHANGED		64

#define ERR_RANGE_OF_TYPE_ADDED			65

#define ERR_RANGE_OF_TYPE_REMOVED		66

#define ERR_TYPE_BASED_ON			67

#define ERR_INDEX_AUGMENT_CHANGED		68

#define ERR_NAMED_NUMBER_OF_TYPE_REMOVED	69

#define ERR_NAMED_NUMBER_TO_TYPE_ADDED		70

#define ERR_NAMED_NUMBER_OF_TYPE_CHANGED	71

#define ERR_NAMED_BIT_OF_TYPE_ADDED_OLD_BYTE	72

#define ERR_LENGTH_REMOVED			73

#define ERR_PREVIOUS_IMPLICIT_DEFINITION	74

#define ERR_STATUS_CHANGED_IMPLICIT		75

#define ERR_LEGAL_STATUS_CHANGED_IMPLICIT	76

#define ERR_LENGTH_OF_TYPE_ADDED		77

#define ERR_LENGTH_OF_TYPE_REMOVED		78

#define ERR_STATUS_ADDED			79

#define ERR_STATUS_REMOVED			80

#define ERR_MANDATORY_GROUP_ADDED		81

#define ERR_MANDATORY_GROUP_REMOVED		82

#define ERR_MANDATORY_EXT_GROUP_ADDED		83

#define ERR_MANDATORY_EXT_GROUP_REMOVED		84

#define ERR_OPTION_ADDED			85

#define ERR_OPTION_REMOVED			86

#define ERR_EXT_OPTION_ADDED			87

#define ERR_EXT_OPTION_REMOVED			88

#define ERR_REFINEMENT_ADDED			89

#define ERR_REFINEMENT_REMOVED			90

#define ERR_EXT_REFINEMENT_ADDED		91

#define ERR_EXT_REFINEMENT_REMOVED		92

#define ERR_MANDATORY_REMOVED			93

#define ERR_MANDATORY_ADDED			94

#define ERR_OPTIONAL_REMOVED			95

#define ERR_OPTIONAL_ADDED			96

#define ERR_MANDATORY_EXT_REMOVED		97

#define ERR_MANDATORY_EXT_ADDED			98

#define ERR_OPTIONAL_EXT_REMOVED		99

#define ERR_OPTIONAL_EXT_ADDED			100

static Error errors[] = {

    { 0, ERR_INTERNAL, "internal", 

      "internal error!!!", NULL },

    { 1, ERR_TYPE_REMOVED, "type-removed",

      "type `%s' has been deleted", NULL },

    { 5, ERR_TYPE_ADDED, "type-added",

      "type `%s' has been added", NULL },

    { 1, ERR_NODE_REMOVED, "node-removed",

      "%s `%s' has been deleted", NULL },

    { 5, ERR_NODE_ADDED, "node-added",

      "%s `%s' has been added", NULL },

    { 1, ERR_BASETYPE_CHANGED, "basetype-changed",

      "base type of `%s' changed", NULL },

    { 5, ERR_DECL_CHANGED, "decl-changed",

      "declaration changed for `%s'", NULL },

    { 5, ERR_LEGAL_STATUS_CHANGED, "status-change",

      "legal status change from `%s' to `%s' for `%s'", NULL },

    { 6, ERR_PREVIOUS_DEFINITION, "previous-definition",

      "previous definition of `%s'", NULL },

    { 2, ERR_STATUS_CHANGED, "status-change",

      "status change from `%s' to `%s' for `%s'", NULL },

    { 5, ERR_DESCR_ADDED, "description-added",

      "description added to `%s'", NULL },

    { 2, ERR_DESCR_REMOVED, "description-removed",

      "description removed from `%s'", NULL },

    { 5, ERR_DESCR_CHANGED, "description-changed",

      "description of %s `%s' changed", NULL },

    { 5, ERR_REF_ADDED, "ref-added",

      "reference added to `%s'", NULL },

    { 3, ERR_REF_REMOVED, "ref-removed",

      "reference removed from `%s'", NULL },

    { 5, ERR_REF_CHANGED, "ref-changed",

      "reference of `%s' changed", NULL },

    { 5, ERR_FORMAT_ADDED, "format-added",

      "format added to `%s'", NULL },

    { 3, ERR_FORMAT_REMOVED, "format-removed",

      "format removed from `%s'", NULL },

    { 5, ERR_FORMAT_CHANGED, "format-changed",

      "format of `%s' changed", NULL },

    { 5, ERR_UNITS_ADDED, "units-added",

      "units added to `%s'", NULL },

    { 3, ERR_UNITS_REMOVED, "units-removed",

      "units removed from `%s'", NULL },

    { 5, ERR_UNITS_CHANGED, "units-changed",

      "units of `%s' changed", NULL },

    { 5, ERR_ACCESS_ADDED, "access-added",

      "access added to `%s'", NULL },

    { 3, ERR_ACCESS_REMOVED, "access-removed",

      "access removed from `%s'", NULL },

    { 5, ERR_ACCESS_CHANGED, "access-changed",

      "access of `%s' changed from `%s' to `%s'", NULL },

    { 5, ERR_NAME_ADDED, "name-added",

      "name added to `%s'", NULL },

    { 3, ERR_NAME_REMOVED, "name-removed",

      "name removed from `%s'", NULL },

    { 5, ERR_NAME_CHANGED, "name-changed",

      "name changed from `%s' to `%s'", NULL },

    { 3, ERR_TO_IMPLICIT, "to-implicit",

      "implicit type for `%s' replaces type `%s'", NULL },

    { 5, ERR_FROM_IMPLICIT, "from-implicit",

      "type `%s' replaces implicit type for `%s'", NULL },

    { 3, ERR_RANGE_ADDED, "range-added",

      "range `%s' added to type used in `%s'", NULL },

    { 3, ERR_RANGE_REMOVED, "range-removed",

      "range `%s' removed from type used in `%s'", NULL },

    { 3, ERR_RANGE_CHANGED, "range-changed",

      "range of type used in `%s' changed from `%s' to `%s'", NULL }, 

    { 3, ERR_DEFVAL_ADDED, "defval-added",

      "default value added to `%s'", NULL },

    { 3, ERR_DEFVAL_REMOVED, "defval-removed",

      "default value removed from `%s'", NULL },

    { 3, ERR_DEFVAL_CHANGED, "defval-changed",

      "default value of `%s' changed", NULL },

    { 5, ERR_ORGA_ADDED, "organization-added",

      "organization added to `%s'", NULL },

    { 3, ERR_ORGA_REMOVED, "organization-removed",

      "organization removed from `%s'", NULL },

    { 5, ERR_ORGA_CHANGED, "organization-changed",

      "organization of `%s' changed", NULL },

    { 5, ERR_CONTACT_ADDED, "contact-added",

      "contact added to `%s'", NULL },

    { 3, ERR_CONTACT_REMOVED, "contact-removed",

      "contact removed from `%s'", NULL },

    { 5, ERR_CONTACT_CHANGED, "contact-changed",

      "contact of `%s' changed", NULL },

    { 3, ERR_SMIVERSION_CHANGED, "smi-version-changed",

      "SMI version changed", NULL },

    { 5, ERR_REVISION_ADDED, "revision-added",

      "revision `%s' added", NULL },

    { 3, ERR_REVISION_REMOVED, "revision-removed",

      "revision `%s' removed", NULL },

    { 5, ERR_REVISION_CHANGED, "revision-changed",

      "revision `%s' changed", NULL },

    { 3, ERR_LENGTH_CHANGED, "range-changed",

      "size of type used in `%s' changed from `%s' to `%s'", NULL },

    { 3, ERR_LENGTH_OF_TYPE_CHANGED, "range-changed",

      "size of type `%s' changed from `%s' to `%s'", NULL },

    { 3, ERR_LENGTH_ADDED, "range-added",

      "size `%s' added to type used in `%s'", NULL },

    { 2, ERR_MEMBER_ADDED, "member-added",

      "member `%s' added to group `%s'", NULL },

    { 2, ERR_MEMBER_REMOVED, "member-removed",

      "member `%s' removed from group `%s'", NULL },

    { 3, ERR_MEMBER_CHANGED, "member-changed",

      "member `%s' changed in group `%s'", NULL },

    { 3, ERR_OBJECT_ADDED, "object-added",

      "object `%s' added", NULL },

    { 2, ERR_OBJECT_REMOVED, "object-removed",

      "object `%s' removed", NULL },

    { 3, ERR_OBJECT_CHANGED, "object-changed",

      "object `%s' changed", NULL },

    { 5, ERR_NAMED_NUMBER_ADDED, "named-number-added",

      "named number `%s' added to type used in `%s'", NULL },

    { 2, ERR_NAMED_NUMBER_REMOVED, "named-number-removed",

      "named number `%s' removed from type used in `%s'", NULL },

    { 5, ERR_NAMED_NUMBER_CHANGED, "named-number-changed",

      "named number `%s' changed to `%s' at type used in `%s'", NULL },

    { 3, ERR_NAMED_BIT_ADDED_OLD_BYTE, "named-bit-added-old-byte",

      "named bit `%s' added without starting in a new byte in type used in `%s'", NULL },

     { 3, ERR_LENGTH_REMOVED, "range-removed",

      "size `%s' removed from type used in `%s'", NULL },

    { 2, ERR_NODEKIND_CHANGED, "nodekind-changed",

      "node kind of `%s' changed", NULL },

    { 2, ERR_INDEXKIND_CHANGED, "indexkind-changed",

      "changed kind of index from `%s' to `%s' in node `%s'", NULL },

    { 2, ERR_INDEX_CHANGED, "index-changed",

      "index of `%s' changed from %s to %s", NULL },

    { 5, ERR_TYPE_IS_AND_WAS, "type-is-and-was",

      "type changed from %s to %s", NULL },

    { 3, ERR_RANGE_OF_TYPE_CHANGED, "range-changed",

      "range of type `%s' changed from `%s' to `%s'", NULL },

    { 3, ERR_RANGE_OF_TYPE_ADDED, "range-added",

      "range `%s' added to type `%s'", NULL },

    { 3, ERR_RANGE_OF_TYPE_REMOVED, "range-removed",

      "range `%s' removed from type `%s'", NULL },

    { 6, ERR_TYPE_BASED_ON, "type-based-on",

      "type `%s' based on `%s'", NULL },

    { 2, ERR_INDEX_AUGMENT_CHANGED, "index-changed",

      "index of `%s' changed from augmenting `%s' to augmenting `%s'", NULL },

    { 2, ERR_NAMED_NUMBER_OF_TYPE_REMOVED, "named-number-removed",

      "named number `%s' removed from type `%s'", NULL },

    { 5, ERR_NAMED_NUMBER_TO_TYPE_ADDED, "named-number-added",

      "named number `%s' added to type `%s'", NULL },

    { 5, ERR_NAMED_NUMBER_OF_TYPE_CHANGED, "named-number-changed",

      "named number `%s' changed to `%s' in type `%s'", NULL },

    { 3, ERR_NAMED_BIT_OF_TYPE_ADDED_OLD_BYTE, "named-bit-added-old-byte",

      "named bit `%s' added without starting in a new byte in type `%s'", NULL },

    { 6, ERR_PREVIOUS_IMPLICIT_DEFINITION, "previous-definition",

      "previous implicit definition", NULL },

    { 2, ERR_STATUS_CHANGED_IMPLICIT, "status-change",

      "status change from `%s' to `%s' for implicit type", NULL },

    { 5, ERR_LEGAL_STATUS_CHANGED_IMPLICIT, "status-change",

      "legal status change from `%s' to `%s' for implicit type", NULL },

    { 3, ERR_LENGTH_OF_TYPE_ADDED, "range-added",

      "size `%s' added to type `%s'", NULL },

    { 3, ERR_LENGTH_OF_TYPE_REMOVED, "range-removed",

      "size `%s' removed from type `%s'", NULL },

    { 5, ERR_STATUS_ADDED, "status-added",

      "status added to `%s'", NULL },

    { 3, ERR_STATUS_REMOVED, "status-removed",

      "status removed from `%s'", NULL },

    { 2, ERR_MANDATORY_GROUP_ADDED, "mandatory-added",

      "mandatory group `%s' added to `%s'", NULL },

    { 2, ERR_MANDATORY_GROUP_REMOVED, "mandatory-removed",

      "mandatory group `%s' removed from `%s'", NULL },

    { 2, ERR_MANDATORY_EXT_GROUP_ADDED, "mandatory-added",

      "mandatory group `%s::%s' added to `%s'", NULL },

    { 2, ERR_MANDATORY_EXT_GROUP_REMOVED, "mandatory-removed",

      "mandatory group `%s::%s' removed from `%s'", NULL },

    { 2, ERR_OPTION_ADDED, "option-added",

      "optional group `%s' added to `%s'", NULL },

    { 2, ERR_OPTION_REMOVED, "option-removed",

      "optional group `%s' removed from `%s'", NULL },

    { 2, ERR_EXT_OPTION_ADDED, "option-added",

      "optional group `%s::%s' added to `%s'", NULL },

    { 2, ERR_EXT_OPTION_REMOVED, "option-removed",

      "optional group `%s::%s' removed from `%s'", NULL },

    { 5, ERR_REFINEMENT_ADDED, "refinement-added",

      "object refinement for `%s' added to `%s'", NULL },

    { 2, ERR_REFINEMENT_REMOVED, "refinement-removed",

      "object refinement for `%s' removed from `%s'", NULL },

    { 5, ERR_EXT_REFINEMENT_ADDED, "refinement-added",

      "object refinement for `%s::%s' added to `%s'", NULL },

    { 2, ERR_EXT_REFINEMENT_REMOVED, "refinement-removed",

      "object refinement for `%s::%s' removed from `%s'", NULL },

    { 3, ERR_MANDATORY_REMOVED, "mandatory-removed",

      "%s `%s' is mandatory under `%s' but not mandatory under `%s'", NULL },

    { 3, ERR_MANDATORY_ADDED, "mandatory-added",

      "%s `%s' is not mandatory under `%s' but mandatory under `%s'", NULL },

    { 3, ERR_OPTIONAL_REMOVED, "optional-removed",

      "%s `%s' is conditionally optional under `%s' but not under `%s'", NULL },

    { 3, ERR_OPTIONAL_ADDED, "optional-added",

      "%s `%s' is not conditionally optional under `%s' but under `%s'", NULL },

    { 3, ERR_MANDATORY_EXT_REMOVED, "mandatory-removed",

      "%s `%s::%s' is mandatory under `%s' but not mandatory under `%s'", NULL },

    { 3, ERR_MANDATORY_EXT_ADDED, "mandatory-added",

      "%s `%s::%s' is not mandatory under `%s' but mandatory under `%s'", NULL },

    { 3, ERR_OPTIONAL_EXT_REMOVED, "optional-removed",

      "%s `%s::%s' is conditionally optional under `%s' but not under `%s'", NULL },

    { 3, ERR_OPTIONAL_EXT_ADDED, "optional-added",

      "%s `%s::%s' is not conditionally optional under `%s' but under `%s'", NULL },

    { 0, 0, NULL, NULL }

};

static char *smiStringDecl(SmiDecl macro)

{

    return

        (macro == SMI_DECL_UNKNOWN)           ? "unknown construct" :

        (macro == SMI_DECL_IMPLICIT_TYPE)     ? "implicit construct" :

        (macro == SMI_DECL_TYPEASSIGNMENT)    ? "type assignment" :

        (macro == SMI_DECL_IMPL_SEQUENCEOF)   ? "implicit sequence-of construct" :

        (macro == SMI_DECL_VALUEASSIGNMENT)   ? "value assignment" :

        (macro == SMI_DECL_OBJECTTYPE)        ? "object definition" :

        (macro == SMI_DECL_OBJECTIDENTITY)    ? "object identity definition" :

        (macro == SMI_DECL_MODULEIDENTITY)    ? "module identity definition" :

        (macro == SMI_DECL_NOTIFICATIONTYPE)  ? "notification definition" :

        (macro == SMI_DECL_TRAPTYPE)          ? "trap definition" :

        (macro == SMI_DECL_OBJECTGROUP)       ? "object group definition" :

        (macro == SMI_DECL_NOTIFICATIONGROUP) ? "notification group definition" :

        (macro == SMI_DECL_MODULECOMPLIANCE)  ? "module compliance definition" :

        (macro == SMI_DECL_AGENTCAPABILITIES) ? "agent capabilities definition" :

        (macro == SMI_DECL_TEXTUALCONVENTION) ? "textual convention definition" :

        (macro == SMI_DECL_MACRO)             ? "macro definition" :

        (macro == SMI_DECL_COMPL_GROUP)       ? "optional group" :

        (macro == SMI_DECL_COMPL_OBJECT)      ? "object refinement" :

        (macro == SMI_DECL_MODULE)	      ? "module" :

        (macro == SMI_DECL_TYPEDEF)	      ? "typedef" :

        (macro == SMI_DECL_NODE)	      ? "node" :

        (macro == SMI_DECL_SCALAR)	      ? "scalar" :

        (macro == SMI_DECL_TABLE)	      ? "table" :

        (macro == SMI_DECL_ROW)		      ? "row" :

        (macro == SMI_DECL_COLUMN)	      ? "column" :

        (macro == SMI_DECL_NOTIFICATION)      ? "notification" :

        (macro == SMI_DECL_GROUP)	      ? "group" :

        (macro == SMI_DECL_COMPLIANCE)	      ? "compliance" :

                                                "<UNDEFINED>";

}

static void

setErrorSeverity(char *pattern, int severity)

{

    int i;

    for (i = 0; errors[i].fmt; i++) {

	if (strstr(errors[i].tag, pattern) == errors[i].tag) {

	    errors[i].level = severity;

	}

    }

}

static void

printError(SmiModule *smiModule, int id, int line, va_list ap)

{

    int i;

    /*

     * Search for the tag instead of just using the id as an index so

     * that we do not run into trouble if the id is bogus.

     */

    for (i = 0; errors[i].fmt; i++) {

	if (errors[i].id == id) break;

    }

    if (! errors[i].fmt) {

	i = 0;		/* assumes that 0 is the internal error */

    }

    if (errors[i].level <= errorLevel) {

	fprintf(stdout, "%s", smiModule->path);

    	if (line >= 0) {

	    fprintf(stdout, ":%d", line);

	}

	fprintf(stdout, " ");

	if (sFlag) {

	    fprintf(stdout, "[%d] ", errors[i].level);

	}

	if (mFlag) {

	    fprintf(stdout, "{%s} ", errors[i].tag);

	}

	switch (errors[i].level) {

	case 4:

	case 5:

	    fprintf(stdout, "warning: ");

	    break;

	case 6:	

	    fprintf(stdout, "info: ");

	    break;

	}

	vfprintf(stdout, errors[i].fmt, ap);

	fprintf(stdout, "\n");

    }

}

static void

printErrorAtLine(SmiModule *smiModule, int id, int line, ...)

{

    va_list ap;

    va_start(ap, line);

    printError(smiModule, id, line, ap);

    va_end(ap);

}

static char*

getStringTime(time_t t)

{

    static char   s[27];

    struct tm	  *tm;

    tm = gmtime(&t);

    sprintf(s, "%04d-%02d-%02d %02d:%02d",

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

	    tm->tm_hour, tm->tm_min);

    return s;

}

static char*

getStringNodekind(SmiNodekind nodekind)

{

    return

	(nodekind == SMI_NODEKIND_UNKNOWN)      ? "unknown" :

	(nodekind == SMI_NODEKIND_NODE)         ? "node" :

	(nodekind == SMI_NODEKIND_SCALAR)       ? "scalar" :

	(nodekind == SMI_NODEKIND_TABLE)        ? "table" :

	(nodekind == SMI_NODEKIND_ROW)          ? "row" :

	(nodekind == SMI_NODEKIND_COLUMN)       ? "column" :

	(nodekind == SMI_NODEKIND_NOTIFICATION) ? "notification" :

	(nodekind == SMI_NODEKIND_GROUP)        ? "group" :

	(nodekind == SMI_NODEKIND_COMPLIANCE)   ? "compliance" :

	(nodekind == SMI_NODEKIND_CAPABILITIES) ? "capabilities" :

                                                  "<unknown>";

}

static int

diffStrings(const char *s1, const char *s2)

{

    int i, j;

    for (i = 0, j = 0; s1[i] && s2[j]; i++, j++) {

	while (s1[i] && isspace((int) s1[i])) i++;

	while (s2[j] && isspace((int) s2[j])) j++;

	if (! s1[i] || ! s2[j]) break;

	if (s1[i] != s2[j]) {

	    return 1;

	}

    }

    return (s1[i] != s2[j]);

}

static int

checkName(SmiModule *oldModule, int oldLine,

	    SmiModule *newModule, int newLine,

	    char *oldName, char *newName)

{

    int code = 0;

    if (!oldName && newName) {

	printErrorAtLine(newModule, ERR_NAME_ADDED,

			 newLine, newName);

    }

    if (oldName && !newName) {

	printErrorAtLine(oldModule, ERR_NAME_REMOVED,

			 oldLine, oldName);

    }

    if (oldName && newName && strcmp(oldName, newName) != 0) {

	printErrorAtLine(newModule, ERR_NAME_CHANGED,

			 newLine, oldName, newName);

	code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

static int

checkDecl(SmiModule *oldModule, int oldLine,

	  SmiModule *newModule, int newLine,

	  char *name, SmiDecl oldDecl, SmiDecl newDecl)

{

    int code = 0;

    if (oldDecl != newDecl) {

	printErrorAtLine(newModule, ERR_DECL_CHANGED,

			 newLine, name);

        code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

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 int

checkStatus(SmiModule *oldModule, int oldLine,

	    SmiModule *newModule, int newLine,

	    char *name, SmiStatus oldStatus, SmiStatus newStatus)

{

    int code = 0;

    if (oldStatus == newStatus) {

	return code;

    }

    if (oldStatus == SMI_STATUS_UNKNOWN) {

	printErrorAtLine(newModule, ERR_STATUS_ADDED,

			 newLine, name);

    } else if (newStatus == SMI_STATUS_UNKNOWN) {

	printErrorAtLine(newModule, ERR_STATUS_REMOVED,

			 newLine, name);

    } else if (((oldStatus == SMI_STATUS_CURRENT

	  && (newStatus == SMI_STATUS_DEPRECATED

	      || newStatus == SMI_STATUS_OBSOLETE)))

	|| ((oldStatus == SMI_STATUS_DEPRECATED

	     && newStatus == SMI_STATUS_OBSOLETE))) {

	if (name) {

	    printErrorAtLine(newModule, ERR_LEGAL_STATUS_CHANGED, newLine,

			     getStringStatus(oldStatus),

			     getStringStatus(newStatus),

			     name);

	    code |= CODE_SHOW_PREVIOUS;

	} else {

	    printErrorAtLine(newModule, ERR_LEGAL_STATUS_CHANGED_IMPLICIT, newLine,

			     getStringStatus(oldStatus),

			     getStringStatus(newStatus));

	    code |= CODE_SHOW_PREVIOUS_IMPLICIT;

	}

    } else {

	if (name) {

	    printErrorAtLine(newModule, ERR_STATUS_CHANGED, newLine,

			     getStringStatus(oldStatus),

			     getStringStatus(newStatus),

			     name);

	    code |= CODE_SHOW_PREVIOUS;

	} else {

	    printErrorAtLine(newModule, ERR_STATUS_CHANGED_IMPLICIT,

			     newLine,

			     getStringStatus(oldStatus),

			     getStringStatus(newStatus));

	    code |= CODE_SHOW_PREVIOUS_IMPLICIT;

	}

    }

    return code;

}

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";

    }

}

static int

checkAccess(SmiModule *oldModule, int oldLine,

	    SmiModule *newModule, int newLine,

	    char *name, SmiAccess oldAccess, SmiAccess newAccess)

{

    int code = 0;

    if (oldAccess == newAccess) {

	return code;

    }

    if (oldAccess == SMI_ACCESS_UNKNOWN) {

	printErrorAtLine(newModule, ERR_ACCESS_ADDED,

			 newLine, name);

    } else if (newAccess == SMI_ACCESS_UNKNOWN) {

	printErrorAtLine(newModule, ERR_ACCESS_REMOVED,

			 newLine, name);

    } else {

	printErrorAtLine(newModule, ERR_ACCESS_CHANGED,

			 newLine, name,

			 getStringAccess( oldAccess ),

			 getStringAccess( newAccess ));

	code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

static int

checkDescription(SmiModule *oldModule, int oldLine,

		 SmiModule *newModule, int newLine,

		 char *name, SmiDecl decl, char *oldDescr, char *newDescr)

{

    int code = 0;

    if (!oldDescr && newDescr) {

	printErrorAtLine(newModule, ERR_DESCR_ADDED,

			 newLine, name);

    }

    if (oldDescr && !newDescr) {

	printErrorAtLine(newModule, ERR_DESCR_REMOVED,

			 newLine, name);

	code |= CODE_SHOW_PREVIOUS;

    }

    if (oldDescr && newDescr && diffStrings(oldDescr, newDescr)) {

	printErrorAtLine(newModule, ERR_DESCR_CHANGED,

			 newLine, smiStringDecl(decl), name);

	code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

static int

checkReference(SmiModule *oldModule, int oldLine,

	       SmiModule *newModule, int newLine,

	       char *name, char *oldRef, char *newRef)

{

    int code = 0;

    if (!oldRef && newRef) {

	printErrorAtLine(newModule, ERR_REF_ADDED,

			 newLine, name);

    }

    if (oldRef && !newRef) {

	printErrorAtLine(oldModule, ERR_REF_REMOVED,

			 oldLine, name);

    }

    if (oldRef && newRef && diffStrings(oldRef, newRef) != 0) {

	printErrorAtLine(newModule, ERR_REF_CHANGED,

			 newLine, name);

	code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

static int

checkFormat(SmiModule *oldModule, int oldLine,

	    SmiModule *newModule, int newLine,

	    char *name, char *oldFormat, char *newFormat)

{

    int code = 0;

    if (!oldFormat && newFormat) {

	printErrorAtLine(newModule, ERR_FORMAT_ADDED,

			 newLine, name);

    }

    if (oldFormat && !newFormat) {

	printErrorAtLine(oldModule, ERR_FORMAT_REMOVED,

			 oldLine, name);

    }

    if (oldFormat && newFormat && strcmp(oldFormat, newFormat) != 0) {

	printErrorAtLine(newModule, ERR_FORMAT_CHANGED,

			 newLine, name);

	code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

static int

checkUnits(SmiModule *oldModule, int oldLine,

	   SmiModule *newModule, int newLine,

	   char *name, char *oldUnits, char *newUnits)

{

    int code = 0;

    if (!oldUnits && newUnits) {

	printErrorAtLine(newModule, ERR_UNITS_ADDED,

			 newLine, name);

    }

    if (oldUnits && !newUnits) {

	printErrorAtLine(oldModule, ERR_UNITS_REMOVED,

			 oldLine, name);

    }

    if (oldUnits && newUnits && strcmp(oldUnits, newUnits) != 0) {

	printErrorAtLine(newModule, ERR_UNITS_CHANGED,

			 newLine, name);

	code |= CODE_SHOW_PREVIOUS;

    }

    return code;

}

static SmiType*

findTypeWithRange(SmiType *smiType)

{

    SmiType *iterType;

    for (iterType = smiType; iterType; iterType = smiGetParentType(iterType)) {

	if (smiGetFirstRange(iterType)) {

	    return iterType;

	}

    }

    return NULL;

}

/* This function assumes that the compared values have the same basetype.

 * If the basetype is different, no comparison is done

 * and '0' will be returned. Same for SMI_BASETYPE_UNKNOWN.

 */

static int 

cmpSmiValues( SmiValue a, SmiValue b )

{

    unsigned int i;

    int changed = 0;

    switch (a.basetype) {

    case SMI_BASETYPE_INTEGER32:

    case SMI_BASETYPE_ENUM :

	changed = (a.value.integer32 != b.value.integer32);

	break;

    case SMI_BASETYPE_UNSIGNED32:

	changed = (a.value.unsigned32 != b.value.unsigned32);

	break;

    case SMI_BASETYPE_INTEGER64:

	changed = (a.value.integer64 != b.value.integer64);

	break;

    case SMI_BASETYPE_UNSIGNED64:

	changed = (a.value.unsigned64 != b.value.unsigned64);

	break;

    case SMI_BASETYPE_FLOAT32:

	changed = (a.value.float32 != b.value.float32);

	break;

    case SMI_BASETYPE_FLOAT64:

	changed = (a.value.float64 != b.value.float64);

	break;

    case SMI_BASETYPE_FLOAT128:

	changed = (a.value.float128 != b.value.float128);

	break;

    case SMI_BASETYPE_OCTETSTRING:

    case SMI_BASETYPE_BITS:

	changed = (a.len != b.len)

	    || (memcmp(a.value.ptr, b.value.ptr, a.len) != 0);

	break;

    case SMI_BASETYPE_OBJECTIDENTIFIER:

	changed = (a.len != b.len);

	for (i = 0; !changed && i < a.len; i++) {

	    changed = (a.value.oid[i] - b.value.oid[i]);

	}

	break;

    case SMI_BASETYPE_UNKNOWN:

    case SMI_BASETYPE_POINTER: