Mercurial > hg > truffle
diff agent/src/share/classes/sun/jvm/hotspot/debugger/win32/coff/DebugVC50TypeIterator.java @ 0:a61af66fc99e jdk7-b24
Initial load
author | duke |
---|---|
date | Sat, 01 Dec 2007 00:00:00 +0000 |
parents | |
children | c18cbe5936b8 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/coff/DebugVC50TypeIterator.java Sat Dec 01 00:00:00 2007 +0000 @@ -0,0 +1,868 @@ +/* + * Copyright 2001 Sun Microsystems, Inc. All Rights Reserved. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * This code is free software; you can redistribute it and/or modify it + * under the terms of the GNU General Public License version 2 only, as + * published by the Free Software Foundation. + * + * This code is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + * version 2 for more details (a copy is included in the LICENSE file that + * accompanied this code). + * + * You should have received a copy of the GNU General Public License version + * 2 along with this work; if not, write to the Free Software Foundation, + * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. + * + * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, + * CA 95054 USA or visit www.sun.com if you need additional information or + * have any questions. + * + */ + +package sun.jvm.hotspot.debugger.win32.coff; + +import java.util.NoSuchElementException; + +/** <p> Provides iteration-style access to the types in the + sstGlobalTypes subsection of the VC++ 5.0 debug + information. Clients should walk down these platform-dependent + types and transform them into the platform-independent interfaces + described in the package sun.jvm.hotspot.debugger.csym. </p> + + <p> This iterator is a "two-dimensional" iterator; it iterates not + only over all of the types in the type table, but also iterates + over the leaf types in the current type string. This structure was + chosen to avoid constructing a new type iterator for each type in + the type table because of the expected large number of types. </p> +*/ + +public interface DebugVC50TypeIterator { + // + // Iteration through type table + // + + /** Indicates whether the iteration through the type table is + complete. */ + public boolean done(); + + /** Go to the next type in the type table. NOTE that the iterator is + pointing at the first type initially, so one should use a while + (!iter.done()) { ... iter.next(); } construct. + + @throw NoSuchElementException if the iterator is already done + and next() is called. */ + public void next() throws NoSuchElementException; + + /** Gets the length, in bytes, of the current type record. */ + public short getLength(); + + /** Gets the type index of the current type. This number is + compatible with type references in symbols and type records. */ + public int getTypeIndex(); + + /** Debugging support only */ + public int getNumTypes(); + + // + // Iteration through type strings + // + + /** Indicates whether iteration through the current type string is + complete. */ + public boolean typeStringDone(); + + /** Goes to the next element in the current type string. NOTE that + the iterator is pointing at the first type initially, so one + should use a while (!iter.typeStringDone()) { ... + iter.typeStringNext(); } construct. + + @throw NoSuchElementException if the iterator is already done + and typeStringNext() is called. */ + public void typeStringNext() throws NoSuchElementException; + + /** Return the leaf index (see {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeLeafIndices}) + for the current element of the current type string. */ + public int typeStringLeaf(); + + /** For debugging: returns the file offset of the current type + string leaf. */ + public int typeStringOffset(); + + // + // Leaf Indices Referenced from Symbols + // + + /////////////////////////// + // LF_MODIFIER accessors // + /////////////////////////// + + // This record is used to indicate the const,r volatile and + // unaligned properties for any particular type. + + /** Type index of the modified type. */ + public int getModifierIndex(); + + /** Attributes specified in MODIFIER_ enums in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public short getModifierAttribute(); + + ////////////////////////// + // LF_POINTER accessors // + ////////////////////////// + + /** Type index of object pointed to. */ + public int getPointerType(); + + /** Pointer attributes. Consists of seven bit fields whose + enumerants are in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}: + PTRTYPE, PTRMODE, ISFLAT32, VOLATILE, CONST, UNALIGNED, and + RESTRICT. */ + public int getPointerAttributes(); + + /** Only valid if the pointer type is BASED_ON_TYPE; retrieves index + of type. */ + public int getPointerBasedOnTypeIndex(); + + /** Only valid if the pointer type is BASED_ON_TYPE; retrieves name + of type. */ + public String getPointerBasedOnTypeName(); + + /** Only valid if the pointer mode is either PTR_TO_DATA_MEMBER or + PTR_TO_METHOD; retrieves the type index of the containing + class. */ + public int getPointerToMemberClass(); + + /** Only valid if the pointer mode is either PTR_TO_DATA_MEMBER or + PTR_TO_METHOD; retrieves the data format of the pointer in + memory. See the PTR_FORMAT enum in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public short getPointerToMemberFormat(); + + //////////////////////// + // LF_ARRAY accessors // + //////////////////////// + + /** Type index of each array element. */ + public int getArrayElementType(); + + /** Type index of indexing variable. */ + public int getArrayIndexType(); + + /** Length of the array in bytes. */ + public int getArrayLength() throws DebugVC50WrongNumericTypeException; + + /** Length-prefixed name of array. */ + public String getArrayName(); + + ///////////////////////////////////////// + // LF_CLASS and LF_STRUCTURE accessors // + ///////////////////////////////////////// + + /** Number of elements in the class or structure. This count + includes direct, virtual, and indirect virtual bases, and + methods including overloads, data members, static data members, + friends, and so on. */ + public short getClassCount(); + + /** Property bit field; see PROPERTY_ enumeration in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public short getClassProperty(); + + /** Type index of the field list for this class. */ + public int getClassFieldList(); + + /** Get new iterator pointing at the field list of this class. */ + public DebugVC50TypeIterator getClassFieldListIterator(); + + /** Type index of the derivation list. This is output by the + compiler as 0x0000 and is filled in by the CVPACK utility to a + LF_DERIVED record containing the type indices of those classes + which immediately inherit the current class. A zero index + indicates that no derivation information is available. A LF_NULL + index indicates that the class is not inherited by other + classes. */ + public int getClassDerivationList(); + + /** Type index of the virtual function table shape descriptor. */ + public int getClassVShape(); + + /** Numeric leaf specifying size in bytes of the structure. */ + public int getClassSize() throws DebugVC50WrongNumericTypeException; + + /** Length-prefixed name of this type. */ + public String getClassName(); + + //////////////////////// + // LF_UNION accessors // + //////////////////////// + + /** Number of fields in the union. */ + public short getUnionCount(); + + /** Property bit field. */ + public short getUnionProperty(); + + /** Type index of field list. */ + public int getUnionFieldList(); + + /** Get new iterator pointing at the field list of this union. */ + public DebugVC50TypeIterator getUnionFieldListIterator(); + + /** Numeric leaf specifying size in bytes of the union. */ + public int getUnionSize() throws DebugVC50WrongNumericTypeException; + + /** Length-prefixed name of union. */ + public String getUnionName(); + + /////////////////////// + // LF_ENUM accessors // + /////////////////////// + + /** Number of enumerates. */ + public short getEnumCount(); + + /** Property bit field. */ + public short getEnumProperty(); + + /** Index of underlying type of enum. */ + public int getEnumType(); + + /** Type index of field list. */ + public int getEnumFieldList(); + + /** Get new iterator pointing at the field list of this enum. */ + public DebugVC50TypeIterator getEnumFieldListIterator(); + + /** Length-prefixed name of enum. */ + public String getEnumName(); + + //////////////////////////// + // LF_PROCEDURE accessors // + //////////////////////////// + + /** Type index of the value returned by the procedure. */ + public int getProcedureReturnType(); + + /** Calling convention of the procedure; see CALLCONV_ enumeration + in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public byte getProcedureCallingConvention(); + + /** Number of parameters. */ + public short getProcedureNumberOfParameters(); + + /** Type index of argument list type record. */ + public int getProcedureArgumentList(); + + /** Get new iterator pointing at the argument list of this procedure. */ + public DebugVC50TypeIterator getProcedureArgumentListIterator(); + + //////////////////////////// + // LF_MFUNCTION accessors // + //////////////////////////// + + /** Type index of the value returned by the procedure. */ + public int getMFunctionReturnType(); + + /** Type index of the containing class of the function. */ + public int getMFunctionContainingClass(); + + /** Type index of the <b>this</b> parameter of the member function. + A type of void indicates that the member function is static and + has no <b>this</b> parameter. */ + public int getMFunctionThis(); + + /** Calling convention of the procedure; see CALLCONV_ enumeration + in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public byte getMFunctionCallingConvention(); + + /** Number of parameters. This count does not include the + <b>this</b> parameter. */ + public short getMFunctionNumberOfParameters(); + + /** List of parameter specifiers. This list does not include the + <b>this</b> parameter. */ + public int getMFunctionArgumentList(); + + /** Get new iterator pointing at the argument list of this member function. */ + public DebugVC50TypeIterator getMFunctionArgumentListIterator(); + + /** Logical <b>this</b> adjustor for the method. Whenever a class + element is referenced via the <b>this</b> pointer, thisadjust + will be added to the resultant offset before referencing the + element. */ + public int getMFunctionThisAdjust(); + + ////////////////////////// + // LF_VTSHAPE accessors // + ////////////////////////// + + // This record describes the format of a virtual function table. + // This record is accessed via the vfunctabptr in the member list of + // the class which introduces the virtual function. The vfunctabptr + // is defined either by the LF_VFUNCTAB or LF_VFUNCOFF member + // record. If LF_VFUNCTAB record is used, then vfunctabptr is at the + // address point of the class. If LF_VFUNCOFF record is used, then + // vfunctabptr is at the specified offset from the class address + // point. The underlying type of the pointer is a VTShape type + // record. This record describes how to interpret the memory at the + // location pointed to by the virtual function table pointer. + + /** Number of descriptors. */ + public short getVTShapeCount(); + + /** Fetch the <i>i</i>th descriptor (0..getVTShapeCount() - 1). Each + descriptor is a 4-bit (half-byte) value described by the + VTENTRY_ enumeration in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public int getVTShapeDescriptor(int i); + + // + // NOTE: LF_COBOL0, LF_COBOL1 accessors elided (FIXME) + // + + ///////////////////////// + // LF_BARRAY accessors // + ///////////////////////// + + /** Type of each element of the array. */ + public int getBasicArrayType(); + + //////////////////////// + // LF_LABEL accessors // + //////////////////////// + + /** Addressing mode of the label, described by LABEL_ADDR_MODE_ enum + in {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums}. */ + public short getLabelAddressMode(); + + // + // LF_NULL, LF_NOTTRANS have no data + // + + /////////////////////////// + // LF_DIMARRAY accessors // + /////////////////////////// + + /** Underlying type of the array. */ + public int getDimArrayType(); + + /** Index of the type record containing the dimension information. */ + public int getDimArrayDimInfo(); + + /** Length-prefixed name of the array. */ + public String getDimArrayName(); + + ////////////////////////// + // LF_VFTPATH accessors // + ////////////////////////// + + /** Count of number of bases in the path to the virtual function + table. */ + public int getVFTPathCount(); + + /** Type indices of the base classes in the path + (0..getVFTPathCount() - 1). */ + public int getVFTPathBase(int i); + + // + // NOTE: LF_PRECOMP and LF_ENDPRECOMP accessors elided because the + // signature contained within is extremely compiler-specific and is + // left undefined in the specification, so is not useful. (FIXME) + // + + // + // NOTE: LF_OEM accessors elided because we will not need to parse + // vendor-specific debug information (yet). (FIXME) + // + + // + // NOTE: LF_TYPESERVER accessors elided because we will not be using + // this library in conjunction with a program database. (FIXME) + // + + // + // Type Records Referenced from Type Records + // + + /////////////////////// + // LF_SKIP accessors // + /////////////////////// + + /** In processing $$TYPES, the index counter is advanced to index + count, skipping all intermediate indices. This is the next valid + index. */ + public int getSkipIndex(); + + ////////////////////////// + // LF_ARGLIST accessors // + ////////////////////////// + + /** Count of number of indices in list. */ + public int getArgListCount(); + + /** List of type indices (0..getArgListCount() - 1) for describing + the formal parameters to a function or method. */ + public int getArgListType(int i); + + ///////////////////////// + // LF_DEFARG accessors // + ///////////////////////// + + /** Type index of resulting expression. */ + public int getDefaultArgType(); + + /** Length-prefixed string of supplied default expression. */ + public String getDefaultArgExpression(); + + // + // Field list accessors (LF_FIELDLIST) + // + // No explicit accessors for the field list. The field list is + // structured similarly to most type strings; it is a series of + // leaves. LF_INDEX leaves are used to split the field list if it + // gets long enough that it will cross a 48K boundary; LF_PAD leaves + // are used to enforce proper alignment. Both of these leaves, and + // their lengths, are understood by this iterator, and LF_INDEX + // leaves have an accessor for reaching the target type record. + // + + ////////////////////////// + // LF_DERIVED accessors // + ////////////////////////// + + // This type record specifies all of the classes that are directly + // derived from the class that references this type record. + + /** Number of types in the list. */ + public int getDerivedCount(); + + /** Fetch <i>i</i>th derived type (0..getDerivedCount() - 1). */ + public int getDerivedType(int i); + + /////////////////////////// + // LF_BITFIELD accessors // + /////////////////////////// + + // Bit fields are represented by an entry in the field list that + // indexes a bit field type definition. + + /** Type index of the field. */ + public int getBitfieldFieldType(); + + /** The length in bits of the object. */ + public byte getBitfieldLength(); + + /** Starting position (from bit 0) of the object in the word. */ + public byte getBitfieldPosition(); + + //////////////////////// + // LF_MLIST accessors // + //////////////////////// + + // This record is typically used to describe overloaded methods, + // though it can also be used (inefficiently) to describe a single + // method. It is referenced from the LF_METHOD record. The "count" + // is not really contained in this record; it is contained within + // the LF_METHOD record which points to this one. However, it seems + // it can be inferred from the length of this type string as the + // only repeated portion of the record is the type of each + // overloaded variant. + // + // Once a method has been found in this list, its symbol is found by + // qualifying the method name with its class (T::name) and then + // searching the symbol table for a symbol by that name with the + // correct type index. Note that the number of repeats is determined + // by the subleaf of the field list that references this LF_MLIST + // record. + + /** Attribute of the member function; see {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums} and {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50MemberAttributes}. */ + public short getMListAttribute(); + + /** Number of types corresponding to this overloaded method. FIXME: + must verify this can be inferred solely from this record's + length. */ + public int getMListLength(); + + /** Type index of the procedure record for the <i>i</i>th occurrence + of the function (0..getMListLength() - 1). */ + public int getMListType(int i); + + /** Convenience routine indicating whether this member function is + introducing virtual. */ + public boolean isMListIntroducingVirtual(); + + /** Present only when property attribute is introducing virtual + (optional). Offset in vtable of the class which contains the + pointer to the function. (FIXME: is this on a per-method or + per-method list basis? If the latter, will have to provide an + iterator for this record.) */ + public int getMListVtabOffset(); + + // + // NOTE: LF_DIMCONU, LF_DIMCONLU, LF_DIMVARU, and LF_DIMVARLU + // accessors elided as these are very likely Fortran-specific + // (FIXME?) + // + + ///////////////////////// + // LF_REFSYM accessors // + ///////////////////////// + + // This record is used to describe a symbol that is referenced by a + // type record. The record is defined because type records cannot + // reference symbols or locations in the $$SYMBOLS table because + // global symbol compaction will move symbols. + + /** Create a new SymbolIterator pointing at the copy of the symbol + this record contains. */ + public DebugVC50SymbolIterator getRefSym(); + + // + // Subfields of complex lists + // + + ///////////////////////// + // LF_BCLASS accessors // + ///////////////////////// + + // This leaf specifies a real base class. If a class inherits real + // base classes, the corresponding REAL Base Class records will + // precede all other member records in the field list of that + // class. Base class records are emitted in left to right + // declaration order for real bases. + + /** Member attribute bit field. */ + public short getBClassAttribute(); + + /** Index to type record of the class. The class name can be + obtained from this record. */ + public int getBClassType(); + + /** Offset of subobject that represents the base class within the + structure. */ + public int getBClassOffset() throws DebugVC50WrongNumericTypeException; + + ////////////////////////// + // LF_VBCLASS accessors // + ////////////////////////// + + // This leaf specifies a directly inherited virtual base class. If a + // class directly inherits virtual base classes, the corresponding + // Direct Virtual BaseClass records will follow all Real Base Class + // member records and precede all other member records in the field + // list of that class. Direct Virtual Base class records are emitted + // in bottommost left-to-right inheritance order for directly + // inherited virtual bases. + + /** Member attribute bit field. */ + public short getVBClassAttribute(); + + /** Index to type record of the direct or indirect virtual base + class. The class name can be obtained from this record. */ + public int getVBClassBaseClassType(); + + /** Type index of the virtual base pointer for this base. */ + public int getVBClassVirtualBaseClassType(); + + /** Numeric leaf specifying the offset of the virtual base pointer + from the address point of the class for this virtual base. */ + public int getVBClassVBPOff() throws DebugVC50WrongNumericTypeException; + + /** Numeric leaf specifying the index into the virtual base + displacement table of the entry that contains the displacement + of the virtual base. The displacement is relative to the address + point of the class plus vbpoff. */ + public int getVBClassVBOff() throws DebugVC50WrongNumericTypeException; + + /////////////////////////// + // LF_IVBCLASS accessors // + /////////////////////////// + + // This leaf specifies indirectly inherited virtual base class. If a + // class indirectly inherits virtual base classes, the corresponding + // Indirect Virtual Base Class records will follow all Real Base + // Class and Direct Virtual Base Class member records and precede + // all other member records in the field list of that class. Direct + // Virtual Base class records are emitted in bottommost + // left-to-right inheritance order for virtual bases. + + /** Member attribute bit field. */ + public short getIVBClassAttribute(); + + /** Index to type record of the direct or indirect virtual base + class. The class name can be obtained from this record. */ + public int getIVBClassBType(); + + /** Type index of the virtual base pointer for this base. */ + public int getIVBClassVBPType(); + + /** Numeric leaf specifying the offset of the virtual base pointer + from the address point of the class for this virtual base. */ + public int getIVBClassVBPOff() throws DebugVC50WrongNumericTypeException; + + /** Numeric leaf specifying the index into the virtual base + displacement table of the entry that contains the displacement + of the virtual base. The displacement is relative to the address + point of the class plus vbpoff. */ + public int getIVBClassVBOff() throws DebugVC50WrongNumericTypeException; + + //////////////////////////// + // LF_ENUMERATE accessors // + //////////////////////////// + + /** Member attribute bit field. */ + public short getEnumerateAttribute(); + + /** Numeric leaf specifying the value of enumerate. */ + public long getEnumerateValue() throws DebugVC50WrongNumericTypeException; + + /** Length-prefixed name of the member field. */ + public String getEnumerateName(); + + //////////////////////////// + // LF_FRIENDFCN accessors // + //////////////////////////// + + /** Index to type record of the friend function. */ + public int getFriendFcnType(); + + /** Length prefixed name of friend function. */ + public String getFriendFcnName(); + + //////////////////////// + // LF_INDEX accessors // + //////////////////////// + + /** Type index. This field is emitted by the compiler when a complex + list needs to be split during writing. */ + public int getIndexValue(); + + /** Create a new type iterator starting at the above index. */ + public DebugVC50TypeIterator getIndexIterator(); + + ///////////////////////// + // LF_MEMBER accessors // + ///////////////////////// + + /** Member attribute bit field. */ + public short getMemberAttribute(); + + /** Index to type record for field. */ + public int getMemberType(); + + /** Numeric leaf specifying the offset of field in the structure. */ + public int getMemberOffset() throws DebugVC50WrongNumericTypeException; + + /** Length-prefixed name of the member field. */ + public String getMemberName(); + + /////////////////////////// + // LF_STMEMBER accessors // + /////////////////////////// + + // This leaf specifies a static data member of a class. Once a + // static data member has been found in this list, its symbol is + // found by qualifying the name with its class (T::name) and then + // searching the symbol table for a symbol by that name with the + // correct type index. + + /** Member attribute bit field. */ + public short getStaticAttribute(); + + /** Index to type record for field. */ + public int getStaticType(); + + /** Length-prefixed name of the member field. */ + public String getStaticName(); + + ///////////////////////// + // LF_METHOD accessors // + ///////////////////////// + + // This leaf specifies the overloaded member functions of a class. + // This type record can also be used to specify a non-overloaded + // method but is inefficient. The LF_ONEMETHOD record should be used + // for non-overloaded methods. + + /** Number of occurrences of function within the class. If the + function is overloaded then there will be multiple entries in + the method list. */ + public short getMethodCount(); + + /** Type index of method list. */ + public int getMethodList(); + + /** Length-prefixed name of method. */ + public String getMethodName(); + + ///////////////////////////// + // LF_NESTEDTYPE accessors // + ///////////////////////////// + + /** Type index of nested type. */ + public int getNestedType(); + + /** Length-prefixed name of type. */ + public String getNestedName(); + + /////////////////////////// + // LF_VFUNCTAB accessors // + /////////////////////////// + + // This leaf specifies virtual table pointers within the class. It + // is a requirement that this record be emitted in the field list + // before any virtual functions are emitted to the field list. + + /** Index to the pointer record describing the pointer. The pointer + will in turn have a LF_VTSHAPE type record as the underlying + type. Note that the offset of the virtual function table pointer + from the address point of the class is always zero. */ + public int getVFuncTabType(); + + //////////////////////////// + // LF_FRIENDCLS accessors // + //////////////////////////// + + /** Index to type record of the friend class. The name of the class + can be obtained from the referenced record. */ + public int getFriendClsType(); + + //////////////////////////// + // LF_ONEMETHOD accessors // + //////////////////////////// + + /** Method attribute; see {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50TypeEnums} and + {@link + sun.jvm.hotspot.debugger.win32.coff.DebugVC50MemberAttributes}. */ + public short getOneMethodAttribute(); + + /** Type index of method. */ + public int getOneMethodType(); + + /** Convenience routine indicating whether this method is + introducing virtual. */ + public boolean isOneMethodIntroducingVirtual(); + + /** Offset in virtual function table if introducing virtual method. + If the method is not an introducing virtual, then this field is + not present. */ + public int getOneMethodVBaseOff(); + + /** Length prefixed name of method. */ + public String getOneMethodName(); + + /////////////////////////// + // LF_VFUNCOFF accessors // + /////////////////////////// + + // This record is used to specify a virtual function table pointer + // at a non-zero offset relative to the address point of a class. + + /** Type index of virtual function table pointer. */ + public int getVFuncOffType(); + + /** Offset of virtual function table pointer relative to address + point of class. */ + public int getVFuncOffOffset(); + + /////////////////////////////// + // LF_NESTEDTYPEEX accessors // + /////////////////////////////// + + // This leaf specifies nested type definition with classes, + // structures, unions, or enums and includes the protection + // attributes that are missing in LF_NESTEDTYPE. + + /** Nested type attribute (protection fields are valid). */ + public short getNestedExAttribute(); + + /** Type index of nested type. */ + public int getNestedExType(); + + /** Length-prefixed name of type. */ + public String getNestedExName(); + + /////////////////////////////// + // LF_MEMBERMODIFY accessors // + /////////////////////////////// + + /** New protection attributes. */ + public short getMemberModifyAttribute(); + + /** Type index of base class that introduced the member. */ + public int getMemberModifyType(); + + /** Length-prefixed name of member. */ + public String getMemberModifyName(); + + //////////////////////////// + // Numeric Leaf accessors // + //////////////////////////// + + /** Fetch the two-byte type (or data, for short integer numeric + leaves) of the numeric leaf at the given offset, in bytes, from + the start of the current leaf. */ + public short getNumericTypeAt(int byteOffset); + + /** The size in bytes of the numeric leaf at the given offset, in + bytes, from the start of the current leaf. + + @throw DebugVC50WrongNumericTypeException if there is no numeric + leaf at the specified byte offset. */ + public int getNumericLengthAt(int byteOffset) + throws DebugVC50WrongNumericTypeException; + + /** Fetch the value of the integer numeric leaf at the given offset, + in bytes, from the start of the current leaf. + + @throw DebugVC50WrongNumericTypeException if the specified + numeric leaf is not of integer type. */ + public int getNumericIntAt(int byteOffset) + throws DebugVC50WrongNumericTypeException; + + /** Fetch the value of the long or integer numeric leaf at the given + offset, in bytes, from the start of the current leaf. + + @throw DebugVC50WrongNumericTypeException if the specified + numeric leaf is not of long or integer type. */ + public long getNumericLongAt(int byteOffset) + throws DebugVC50WrongNumericTypeException; + + /** Fetch the value of the single-precision floating-point numeric + leaf at the given offset, in bytes, from the start of the + current leaf. + + @throw DebugVC50WrongNumericTypeException if the specified + numeric leaf is not of 32-bit float type. */ + public float getNumericFloatAt(int byteOffset) + throws DebugVC50WrongNumericTypeException; + + /** Fetch the value of the double-precision floating-point numeric + leaf at the given offset, in bytes, from the start of the + current leaf. + + @throw DebugVC50WrongNumericTypeException if the specified + numeric leaf is not of 64-bit float type. */ + public double getNumericDoubleAt(int byteOffset) + throws DebugVC50WrongNumericTypeException; + + /** Fetch the raw bytes, including LF_ prefix (if any), of the + numeric leaf at the given offset, in bytes, from the start of + the current leaf. + + @throw DebugVC50WrongNumericTypeException if there is no numeric + leaf at the specified byte offset. */ + public byte[] getNumericDataAt(int byteOffset) + throws DebugVC50WrongNumericTypeException; +}