DISMAN-EXPRESSION-MIB DEFINITIONS ::= BEGIN

IMPORTS

    MODULE-IDENTITY, OBJECT-TYPE,

    Integer32, Gauge32, Unsigned32,

    Counter32, Counter64, IpAddress,

    TimeTicks, mib-2, zeroDotZero  FROM SNMPv2-SMI

    RowStatus, TruthValue, TimeStamp    FROM SNMPv2-TC

    sysUpTime                 FROM SNMPv2-MIB

    SnmpAdminString           FROM SNMP-FRAMEWORK-MIB

    MODULE-COMPLIANCE, OBJECT-GROUP     FROM SNMPv2-CONF;

dismanExpressionMIB MODULE-IDENTITY

    LAST-UPDATED "200010160000Z" -- 16 October 2000

    ORGANIZATION "IETF Distributed Management Working Group"

    CONTACT-INFO "Ramanathan Kavasseri

                  Cisco Systems, Inc.

                  170 West Tasman Drive,

                  San Jose CA 95134-1706.

                  Phone: +1 408 527 2446

                  Email: ramk@cisco.com"

    DESCRIPTION

     "The MIB module for defining expressions of MIB objects for

     management purposes."

-- Revision History

       REVISION     "200010160000Z" -- 16 October 2000

       DESCRIPTION  "This is the initial version of this MIB.

                    Published as RFC 2982"

    ::= { mib-2 90 }

dismanExpressionMIBObjects OBJECT IDENTIFIER ::=

                                            { dismanExpressionMIB 1 }

expResource    OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 1 }

expDefine OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 2 }

expValue  OBJECT IDENTIFIER ::= { dismanExpressionMIBObjects 3 }

--

-- Resource Control

--

expResourceDeltaMinimum OBJECT-TYPE

    SYNTAX      Integer32 (-1 | 1..600)

    UNITS       "seconds"

    MAX-ACCESS  read-write

    STATUS      current

    DESCRIPTION

     "The minimum expExpressionDeltaInterval this system will

     accept.  A system may use the larger values of this minimum to

     lessen the impact of constantly computing deltas.  For larger

     delta sampling intervals the system samples less often and

     suffers less overhead.  This object provides a way to enforce

     such lower overhead for all expressions created after it is

     set.

     The value -1 indicates that expResourceDeltaMinimum is

     irrelevant as the system will not accept 'deltaValue' as a

     value for expObjectSampleType.

     Unless explicitly resource limited, a system's value for

     this object should be 1, allowing as small as a 1 second

     interval for ongoing delta sampling.

     Changing this value will not invalidate an existing setting

     of expObjectSampleType."

    ::= { expResource 1 }

expResourceDeltaWildcardInstanceMaximum OBJECT-TYPE

    SYNTAX      Unsigned32

    UNITS       "instances"

    MAX-ACCESS  read-write

    STATUS      current

    DESCRIPTION

     "For every instance of a deltaValue object, one dynamic instance

     entry is needed for holding the instance value from the previous

     sample, i.e. to maintain state.

     This object limits maximum number of dynamic instance entries

     this system will support for wildcarded delta objects in

     expressions. For a given delta expression, the number of

     dynamic instances is the number of values that meet all criteria

     to exist times the number of delta values in the expression.

     A value of 0 indicates no preset limit, that is, the limit

     is dynamic based on system operation and resources.

     Unless explicitly resource limited, a system's value for

     this object should be 0.

     Changing this value will not eliminate or inhibit existing delta

     wildcard instance objects but will prevent the creation of more

     such objects.

     An attempt to allocate beyond the limit results in expErrorCode

     being tooManyWildcardValues for that evaluation attempt."

    ::= { expResource 2 }

expResourceDeltaWildcardInstances OBJECT-TYPE

    SYNTAX      Gauge32

    UNITS       "instances"

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The number of currently active instance entries as

     defined for expResourceDeltaWildcardInstanceMaximum."

    ::= { expResource 3 }

expResourceDeltaWildcardInstancesHigh OBJECT-TYPE

    SYNTAX      Gauge32

    UNITS       "instances"

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The highest value of expResourceDeltaWildcardInstances

     that has occurred since initialization of the managed

     system."

    ::= { expResource 4 }

expResourceDeltaWildcardInstanceResourceLacks OBJECT-TYPE

    SYNTAX      Counter32

    UNITS       "instances"

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The number of times this system could not evaluate an

     expression because that would have created a value instance in

     excess of expResourceDeltaWildcardInstanceMaximum."

    ::= { expResource 5 }

--

-- Definition

--

-- Expression Definition Table

--

expExpressionTable OBJECT-TYPE

    SYNTAX      SEQUENCE OF ExpExpressionEntry

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "A table of expression definitions."

    ::= { expDefine 1 }

expExpressionEntry OBJECT-TYPE

    SYNTAX      ExpExpressionEntry

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "Information about a single expression.  New expressions

     can be created using expExpressionRowStatus.

     To create an expression first create the named entry in this

     table.  Then use expExpressionName to populate expObjectTable.

     For expression evaluation to succeed all related entries in

     expExpressionTable and expObjectTable must be 'active'.  If

     these conditions are not met the corresponding values in

     expValue simply are not instantiated.

     Deleting an entry deletes all related entries in expObjectTable

     and expErrorTable.

     Because of the relationships among the multiple tables for an

     expression (expExpressionTable, expObjectTable, and

     expValueTable) and the SNMP rules for independence in setting

     object values, it is necessary to do final error checking when

     an expression is evaluated, that is, when one of its instances

     in expValueTable is read or a delta interval expires.  Earlier

     checking need not be done and an implementation may not impose

     any ordering on the creation of objects related to an

     expression.

     To maintain security of MIB information, when creating a new row in

     this table, the managed system must record the security credentials

     of the requester.  These security credentials are the parameters

     necessary as inputs to isAccessAllowed from the Architecture for

     Describing SNMP Management Frameworks.  When obtaining the objects

     that make up the expression, the system must (conceptually) use

     isAccessAllowed to ensure that it does not violate security.

     The evaluation of the expression takes place under the

     security credentials of the creator of its expExpressionEntry.

     Values of read-write objects in this table may be changed

     at any time."

    INDEX       { expExpressionOwner, expExpressionName }

    ::= { expExpressionTable 1 }

ExpExpressionEntry ::= SEQUENCE {

    expExpressionOwner           SnmpAdminString,

    expExpressionName             SnmpAdminString,

    expExpression                OCTET STRING,

    expExpressionValueType       INTEGER,

    expExpressionComment         SnmpAdminString,

    expExpressionDeltaInterval   Integer32,

    expExpressionPrefix           OBJECT IDENTIFIER,

    expExpressionErrors          Counter32,

    expExpressionEntryStatus     RowStatus

}

expExpressionOwner OBJECT-TYPE

   SYNTAX      SnmpAdminString (SIZE(0..32))

   MAX-ACCESS  not-accessible

   STATUS      current

   DESCRIPTION

     "The owner of this entry. The exact semantics of this

     string are subject to the security policy defined by the

     security administrator."

    ::= { expExpressionEntry 1 }

expExpressionName OBJECT-TYPE

    SYNTAX      SnmpAdminString (SIZE (1..32))

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "The name of the expression.  This is locally unique, within

     the scope of an expExpressionOwner."

    ::= { expExpressionEntry 2 }

expExpression OBJECT-TYPE

    SYNTAX      OCTET STRING (SIZE (1..1024))

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "The expression to be evaluated.  This object is the same

     as a DisplayString (RFC 1903) except for its maximum length.

     Except for the variable names the expression is in ANSI C

     syntax.  Only the subset of ANSI C operators and functions

     listed here is allowed.

     Variables are expressed as a dollar sign ('$') and an

     integer that corresponds to an expObjectIndex.  An

     example of a valid expression is:

          ($1-$5)*100

     Expressions must not be recursive, that is although an expression

     may use the results of another expression, it must not contain

     any variable that is directly or indirectly a result of its own

     evaluation. The managed system must check for recursive

     expressions.

     The only allowed operators are:

          ( )

          - (unary)

          + - * / %

          & | ^ << >> ~

          ! && || == != > >= < <=

     Note the parentheses are included for parenthesizing the

     expression, not for casting data types.

     The only constant types defined are:

          int (32-bit signed)

          long (64-bit signed)

          unsigned int

          unsigned long

          hexadecimal

          character

          string

          oid

     The default type for a positive integer is int unless it is too

     large in which case it is long.

     All but oid are as defined for ANSI C.  Note that a

     hexadecimal constant may end up as a scalar or an array of

     8-bit integers.  A string constant is enclosed in double

     quotes and may contain back-slashed individual characters

     as in ANSI C.

     An oid constant comprises 32-bit, unsigned integers and at

     least one period, for example:

          0.

          .0

          1.3.6.1

     No additional leading or trailing subidentifiers are automatically

     added to an OID constant.  The constant is taken as expressed.

     Integer-typed objects are treated as 32- or 64-bit, signed

     or unsigned integers, as appropriate.  The results of

     mixing them are as for ANSI C, including the type of the

     result.  Note that a 32-bit value is thus promoted to 64 bits

     only in an operation with a 64-bit value.  There is no

     provision for larger values to handle overflow.

     Relative to SNMP data types, a resulting value becomes

     unsigned when calculating it uses any unsigned value,

     including a counter.  To force the final value to be of

     data type counter the expression must explicitly use the

     counter32() or counter64() function (defined below).

     OCTET STRINGS and OBJECT IDENTIFIERs are treated as

     one-dimensioned arrays of unsigned 8-bit integers and

     unsigned 32-bit integers, respectively.

     IpAddresses are treated as 32-bit, unsigned integers in

     network byte order, that is, the hex version of 255.0.0.0 is

     0xff000000.

     Conditional expressions result in a 32-bit, unsigned integer

     of value 0 for false or 1 for true. When an arbitrary value

     is used as a boolean 0 is false and non-zero is true.

     Rules for the resulting data type from an operation, based on

     the operator:

     For << and >> the result is the same as the left hand operand.

     For &&, ||, ==, !=, <, <=, >, and >= the result is always

     Unsigned32.

     For unary - the result is always Integer32.

     For +, -, *, /, %, &, |, and ^ the result is promoted according

     to the following rules, in order from most to least preferred:

          If left hand and right hand operands are the same type,

          use that.

          If either side is Counter64, use that.

          If either side is IpAddress, use that.

          If either side is TimeTicks, use that.

          If either side is Counter32, use that.

          Otherwise use Unsigned32.

     The following rules say what operators apply with what data

     types.  Any combination not explicitly defined does not work.

     For all operators any of the following can be the left hand or

     right hand operand: Integer32, Counter32, Unsigned32, Counter64.

     The operators +, -, *, /, %, <, <=, >, and >= work with

     TimeTicks.

     The operators &, |, and ^ work with IpAddress.

     The operators << and >> work with IpAddress but only as the

     left hand operand.

     The + operator performs a concatenation of two OCTET STRINGs or

     two OBJECT IDENTIFIERs.

     The operators &, | perform bitwise operations on OCTET STRINGs.

     If the OCTET STRING happens to be a DisplayString the results

     may be meaningless, but the agent system does not check this as

     some such systems do not have this information.

     The operators << and >> perform bitwise operations on OCTET

     STRINGs appearing as the left hand operand.

     The only functions defined are:

          counter32

          counter64

          arraySection

          stringBegins

          stringEnds

          stringContains

          oidBegins

          oidEnds

          oidContains

          average

          maximum

          minimum

          sum

          exists

     The following function definitions indicate their parameters by

     naming the data type of the parameter in the parameter's position

     in the parameter list.  The parameter must be of the type indicated

     and generally may be a constant, a MIB object, a function, or an

     expression.

     counter32(integer) - wrapped around an integer value counter32

     forces Counter32 as a data type.

     counter64(integer) - similar to counter32 except that the

     resulting data type is 'counter64'.

     arraySection(array, integer, integer) - selects a piece of an

     array (i.e. part of an OCTET STRING or OBJECT IDENTIFIER).  The

     integer arguments are in the range 0 to 4,294,967,295.  The

     first is an initial array index (one-dimensioned) and the second

     is an ending array index.  A value of 0 indicates first or last

     element, respectively.  If the first element is larger than the

     array length the result is 0 length.  If the second integer is

     less than or equal to the first, the result is 0 length.  If the

     second is larger than the array length it indicates last

     element.

     stringBegins/Ends/Contains(octetString, octetString) - looks for

     the second string (which can be a string constant) in the first

     and returns the one-dimensioned arrayindex where the match began.

     A return value of 0 indicates no match (i.e. boolean false).

     oidBegins/Ends/Contains(oid, oid) - looks for the second OID

     (which can be an OID constant) in the first and returns the

     the one-dimensioned index where the match began. A return value

     of 0 indicates no match (i.e. boolean false).

     average/maximum/minimum(integer) - calculates the average,

     minimum, or maximum value of the integer valued object over

     multiple sample times.  If the object disappears for any

     sample period, the accumulation and the resulting value object

     cease to exist until the object reappears at which point the

     calculation starts over.

     sum(integerObject*) - sums all available values of the

     wildcarded integer object, resulting in an integer scalar.  Must

     be used with caution as it wraps on overflow with no

     notification.

     exists(anyTypeObject) - verifies the object instance exists. A

     return value of 0 indicates NoSuchInstance (i.e. boolean

     false)."

    ::= { expExpressionEntry 3 }

expExpressionValueType OBJECT-TYPE

    SYNTAX      INTEGER { counter32(1), unsigned32(2), timeTicks(3),

                 integer32(4), ipAddress(5), octetString(6),

                 objectId(7), counter64(8) }

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "The type of the expression value.  One and only one of the

     value objects in expValueTable will be instantiated to match

     this type.

     If the result of the expression can not be made into this type,

     an invalidOperandType error will occur."

    DEFVAL      { counter32 }

    ::= { expExpressionEntry 4 }

expExpressionComment OBJECT-TYPE

    SYNTAX      SnmpAdminString

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "A comment to explain the use or meaning of the expression."

    DEFVAL      { ''H }

    ::= { expExpressionEntry 5 }

expExpressionDeltaInterval OBJECT-TYPE

    SYNTAX      Integer32 (0..86400)

    UNITS       "seconds"

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "Sampling interval for objects in this expression with

     expObjectSampleType 'deltaValue'.

     This object has no effect if the the expression has no

     deltaValue objects.

     A value of 0 indicates no automated sampling.  In this case

     the delta is the difference from the last time the expression

     was evaluated.  Note that this is subject to unpredictable

     delta times in the face of retries or multiple managers.

     A value greater than zero is the number of seconds between

     automated samples.

     Until the delta interval has expired once the delta for the

     object is effectively not instantiated and evaluating

     the expression has results as if the object itself were not

     instantiated.

     Note that delta values potentially consume large amounts of

     system CPU and memory.  Delta state and processing must

     continue constantly even if the expression is not being used.

     That is, the expression is being evaluated every delta interval,

     even if no application is reading those values.  For wildcarded

     objects this can be substantial overhead.

     Note that delta intervals, external expression value sampling

     intervals and delta intervals for expressions within other

     expressions can have unusual interactions as they are impossible

     to synchronize accurately.  In general one interval embedded

     below another must be enough shorter that the higher sample

     sees relatively smooth, predictable behavior.  So, for example,

     to avoid the higher level getting the same sample twice, the

     lower level should sample at least twice as fast as the higher

     level does."

    DEFVAL      { 0 }

    ::= { expExpressionEntry 6 }

expExpressionPrefix OBJECT-TYPE

    SYNTAX      OBJECT IDENTIFIER

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "An object prefix to assist an application in determining

     the instance indexing to use in expValueTable, relieving the

     application of the need to scan the expObjectTable to

     determine such a prefix.

     See expObjectTable for information on wildcarded objects.

     If the expValueInstance portion of the value OID may

     be treated as a scalar (that is, normally, 0) the value of

     expExpressionPrefix is zero length, that is, no OID at all.

     Note that zero length implies a null OID, not the OID 0.0.

     Otherwise, the value of expExpressionPrefix is the expObjectID

     value of any one of the wildcarded objects for the expression.

     This is sufficient, as the remainder, that is, the instance

     fragment relevant to instancing the values, must be the same for

     all wildcarded objects in the expression."

    ::= { expExpressionEntry 7 }

expExpressionErrors OBJECT-TYPE

    SYNTAX      Counter32

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The number of errors encountered while evaluating this

     expression.

     Note that an object in the expression not being accessible,

     is not considered an error. An example of an inaccessible

     object is when the object is excluded from the view of the

     user whose security credentials are used in the expression

     evaluation. In such cases, it is a legitimate condition

     that causes the corresponding expression value not to be

     instantiated."

    ::= { expExpressionEntry 8 }

expExpressionEntryStatus OBJECT-TYPE

    SYNTAX      RowStatus

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "The control that allows creation and deletion of entries."

    ::= { expExpressionEntry 9 }

--

-- Expression Error Table

--

expErrorTable OBJECT-TYPE

    SYNTAX      SEQUENCE OF ExpErrorEntry

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "A table of expression errors."

    ::= { expDefine 2 }

expErrorEntry OBJECT-TYPE

    SYNTAX      ExpErrorEntry

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "Information about errors in processing an expression.

     Entries appear in this table only when there is a matching

     expExpressionEntry and then only when there has been an

     error for that expression as reflected by the error codes

     defined for expErrorCode."

    INDEX       { expExpressionOwner, expExpressionName }

    ::= { expErrorTable 1 }

ExpErrorEntry ::= SEQUENCE {

    expErrorTime       TimeStamp,

    expErrorIndex      Integer32,

    expErrorCode       INTEGER,

    expErrorInstance   OBJECT IDENTIFIER

}

expErrorTime OBJECT-TYPE

    SYNTAX      TimeStamp

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The value of sysUpTime the last time an error caused a

     failure to evaluate this expression."

    ::= { expErrorEntry 1 }

expErrorIndex OBJECT-TYPE

    SYNTAX      Integer32

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The one-dimensioned character array index into

     expExpression for where the error occurred.  The value

     zero indicates irrelevance."

    ::= { expErrorEntry 2 }

expErrorCode OBJECT-TYPE

    SYNTAX      INTEGER {

          invalidSyntax(1),

          undefinedObjectIndex(2),

          unrecognizedOperator(3),

          unrecognizedFunction(4),

          invalidOperandType(5),

          unmatchedParenthesis(6),

          tooManyWildcardValues(7),

          recursion(8),

          deltaTooShort(9),

          resourceUnavailable(10),

          divideByZero(11)

          }

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The error that occurred.  In the following explanations the

     expected timing of the error is in parentheses.  'S' means

     the error occurs on a Set request.  'E' means the error

     occurs on the attempt to evaluate the expression either due to

     Get from expValueTable or in ongoing delta processing.

     invalidSyntax       the value sent for expExpression is not

                    valid Expression MIB expression syntax

                    (S)

     undefinedObjectIndex     an object reference ($n) in

                    expExpression does not have a matching

                    instance in expObjectTable (E)

     unrecognizedOperator     the value sent for expExpression held an

                    unrecognized operator (S)

     unrecognizedFunction     the value sent for expExpression held an

                    unrecognized function name (S)

     invalidOperandType  an operand in expExpression is not the

                    right type for the associated operator

                    or result (SE)

     unmatchedParenthesis     the value sent for expExpression is not

                    correctly parenthesized (S)

     tooManyWildcardValues    evaluating the expression exceeded the

                    limit set by

                    expResourceDeltaWildcardInstanceMaximum

                    (E)

     recursion      through some chain of embedded

                    expressions the expression invokes itself

                    (E)

     deltaTooShort       the delta for the next evaluation passed

                    before the system could evaluate the

                    present sample (E)

     resourceUnavailable some resource, typically dynamic memory,

                    was unavailable (SE)

     divideByZero        an attempt to divide by zero occurred

                    (E)

     For the errors that occur when the attempt is made to set

     expExpression Set request fails with the SNMP error code

     'wrongValue'.  Such failures refer to the most recent failure to

     Set expExpression, not to the present value of expExpression

     which must be either unset or syntactically correct.

     Errors that occur during evaluation for a Get* operation return

     the SNMP error code 'genErr' except for 'tooManyWildcardValues'

     and 'resourceUnavailable' which return the SNMP error code

     'resourceUnavailable'."

    ::= { expErrorEntry 3 }

expErrorInstance OBJECT-TYPE

    SYNTAX      OBJECT IDENTIFIER

    MAX-ACCESS  read-only

    STATUS      current

    DESCRIPTION

     "The expValueInstance being evaluated when the error

     occurred.  A zero-length indicates irrelevance."

    ::= { expErrorEntry 4 }

--

-- Object Table

--

expObjectTable OBJECT-TYPE

    SYNTAX      SEQUENCE OF ExpObjectEntry

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "A table of object definitions for each expExpression.

     Wildcarding instance IDs:

     It is legal to omit all or part of the instance portion for

     some or all of the objects in an expression. (See the

     DESCRIPTION of expObjectID for details.  However, note that

     if more than one object in the same expression is wildcarded

     in this way, they all must be objects where that portion of

     the instance is the same.  In other words, all objects may be

     in the same SEQUENCE or in different SEQUENCEs but with the

     same semantic index value (e.g., a value of ifIndex)

     for the wildcarded portion."

    ::= { expDefine 3 }

expObjectEntry OBJECT-TYPE

    SYNTAX      ExpObjectEntry

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "Information about an object.  An application uses

     expObjectEntryStatus to create entries in this table while

     in the process of defining an expression.

     Values of read-create objects in this table may be

     changed at any time."

    INDEX       { expExpressionOwner, expExpressionName, expObjectIndex }

    ::= { expObjectTable 1 }

ExpObjectEntry ::= SEQUENCE {

    expObjectIndex                     Unsigned32,

    expObjectID                        OBJECT IDENTIFIER,

    expObjectIDWildcard                TruthValue,

    expObjectSampleType                INTEGER,

    expObjectDeltaDiscontinuityID      OBJECT IDENTIFIER,

    expObjectDiscontinuityIDWildcard   TruthValue,

    expObjectDiscontinuityIDType       INTEGER,

    expObjectConditional               OBJECT IDENTIFIER,

    expObjectConditionalWildcard       TruthValue,

    expObjectEntryStatus               RowStatus

}

expObjectIndex OBJECT-TYPE

    SYNTAX      Unsigned32 (1..4294967295)

    MAX-ACCESS  not-accessible

    STATUS      current

    DESCRIPTION

     "Within an expression, a unique, numeric identification for an

     object.  Prefixed with a dollar sign ('$') this is used to

     reference the object in the corresponding expExpression."

    ::= { expObjectEntry 1 }

expObjectID OBJECT-TYPE

    SYNTAX      OBJECT IDENTIFIER

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "The OBJECT IDENTIFIER (OID) of this object.  The OID may be

     fully qualified, meaning it includes a complete instance

     identifier part (e.g., ifInOctets.1 or sysUpTime.0), or it

     may not be fully qualified, meaning it may lack all or part

     of the instance identifier.  If the expObjectID is not fully

     qualified, then expObjectWildcard must be set to true(1).

     The value of the expression will be multiple

     values, as if done for a GetNext sweep of the object.

     An object here may itself be the result of an expression but

     recursion is not allowed.

     NOTE:  The simplest implementations of this MIB may not allow

     wildcards."

    ::= { expObjectEntry 2 }

expObjectIDWildcard  OBJECT-TYPE

    SYNTAX      TruthValue

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

        "A true value indicates the expObjecID of this row is a wildcard

        object. False indicates that expObjectID is fully instanced.

        If all expObjectWildcard values for a given expression are FALSE,

        expExpressionPrefix will reflect a scalar object (i.e. will

        be 0.0).

        NOTE:  The simplest implementations of this MIB may not allow

        wildcards."

    DEFVAL      { false }

    ::= { expObjectEntry 3 }

expObjectSampleType OBJECT-TYPE

    SYNTAX      INTEGER { absoluteValue(1), deltaValue(2),

                          changedValue(3) }

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "The method of sampling the selected variable.

     An 'absoluteValue' is simply the present value of the object.

     A 'deltaValue' is the present value minus the previous value,

     which was sampled expExpressionDeltaInterval seconds ago.

     This is intended primarily for use with SNMP counters, which are

     meaningless as an 'absoluteValue', but may be used with any

     integer-based value.

     A 'changedValue' is a boolean for whether the present value is

     different from the previous value.  It is applicable to any data

     type and results in an Unsigned32 with value 1 if the object's

     value is changed and 0 if not.  In all other respects it is as a

     'deltaValue' and all statements and operation regarding delta

     values apply to changed values.

     When an expression contains both delta and absolute values

     the absolute values are obtained at the end of the delta

     period."

    DEFVAL      { absoluteValue }

    ::= { expObjectEntry 4 }

sysUpTimeInstance OBJECT IDENTIFIER ::= { sysUpTime 0 }

expObjectDeltaDiscontinuityID OBJECT-TYPE

    SYNTAX      OBJECT IDENTIFIER

    MAX-ACCESS  read-create

    STATUS      current

    DESCRIPTION

     "The OBJECT IDENTIFIER (OID) of a TimeTicks, TimeStamp, or

     DateAndTime object that indicates a discontinuity in the value

     at expObjectID.

     This object is instantiated only if expObjectSampleType is

     'deltaValue' or 'changedValue'.

     The OID may be for a leaf object (e.g. sysUpTime.0) or may

     be wildcarded to match expObjectID.

     This object supports normal checking for a discontinuity in a

     counter.  Note that if this object does not point to sysUpTime

     discontinuity checking must still check sysUpTime for an overall

     discontinuity.

     If the object identified is not accessible no discontinuity

     check will be made."

    DEFVAL      { sysUpTimeInstance }

    ::= { expObjectEntry 5 }

expObjectDiscontinuityIDWildcard OBJECT-TYPE

     SYNTAX      TruthValue

     MAX-ACCESS  read-create

     STATUS      current

     DESCRIPTION

     "A true value indicates the expObjectDeltaDiscontinuityID of

     this row is a wildcard object.  False indicates that

     expObjectDeltaDiscontinuityID is fully instanced.

     This object is instantiated only if expObjectSampleType is

     'deltaValue' or 'changedValue'.

     NOTE:  The simplest implementations of this MIB may not allow

     wildcards."

    DEFVAL      { false }

     ::= { expObjectEntry 6 }

expObjectDiscontinuityIDType OBJECT-TYPE

     SYNTAX      INTEGER { timeTicks(1), timeStamp(2), dateAndTime(3) }