sa-jdi

   case 308: 
          return new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SSStaticSymImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, ssType, iMod, cb, lfo);
        }
        throw new COFFException("Unknown section type " + ssType);
      }
    }
    
    class DebugVC50SubsectionImpl
      implements DebugVC50Subsection
    {
      private short ssType;
      private short iMod;
      private int ssSize;
      
      DebugVC50SubsectionImpl(short ssType, short iMod, int ssSize, int offset)
      {
        this.ssType = ssType;
        this.iMod = iMod;
        this.ssSize = ssSize;
      }
      
      public short getSubsectionType()
      {
        return ssType;
      }
      
      public short getSubsectionModuleIndex()
      {
        return iMod;
      }
      
      public int getSubsectionSize()
      {
        return ssSize;
      }
    }
    
    class DebugVC50SSModuleImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSModule
    {
      private int offset;
      private short ovlNumber;
      private short iLib;
      private short cSeg;
      private short style;
      private MemoizedObject segInfo;
      private MemoizedObject name;
      private static final int HEADER_SIZE = 8;
      private static final int SEG_INFO_SIZE = 12;
      
      DebugVC50SSModuleImpl(short ssType, short iMod, int ssSize, final int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this.offset = offset;
        this$1.seek(offset);
        ovlNumber = this$1.readShort();
        iLib = this$1.readShort();
        cSeg = this$1.readShort();
        style = this$1.readShort();
        segInfo = new MemoizedObject()
        {
          public Object computeValue()
          {
            int base = offset + 8;
            DebugVC50SegInfo[] res = new DebugVC50SegInfo[cSeg];
            for (int i = 0; i < cSeg; i++)
            {
              res[i] = new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SegInfoImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base);
              base += 12;
            }
            return res;
          }
        };
        name = new MemoizedObject()
        {
          public Object computeValue()
          {
            return COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this.readLengthPrefixedStringAt(offset + (8 + cSeg * 12));
          }
        };
      }
      
      public short getOverlayNumber()
      {
        return ovlNumber;
      }
      
      public short getLibrariesIndex()
      {
        return iLib;
      }
      
      public short getNumCodeSegments()
      {
        return cSeg;
      }
      
      public short getDebuggingStyle()
      {
        return style;
      }
      
      public DebugVC50SegInfo getSegInfo(int i)
      {
        return ((DebugVC50SegInfo[])(DebugVC50SegInfo[])segInfo.getValue())[i];
      }
      
      public String getName()
      {
        return (String)name.getValue();
      }
    }
    
    class DebugVC50SegInfoImpl
      implements DebugVC50SegInfo
    {
      private short seg;
      private int offset;
      private int cbSeg;
      
      DebugVC50SegInfoImpl(int offset)
      {
        this$1.seek(offset);
        seg = this$1.readShort();
        this$1.readShort();
        offset = this$1.readInt();
        cbSeg = this$1.readInt();
      }
      
      public short getSegment()
      {
        return seg;
      }
      
      public int getOffset()
      {
        return offset;
      }
      
      public int getSegmentCodeSize()
      {
        return cbSeg;
      }
    }
    
    class DebugVC50SSTypesImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSTypes
    {
      DebugVC50SSTypesImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSPublicImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSPublic
    {
      DebugVC50SSPublicImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSPublicSymImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSPublicSym
    {
      DebugVC50SSPublicSymImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSSymbolsImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSSymbols
    {
      DebugVC50SSSymbolsImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSAlignSymImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSAlignSym
    {
      private int offset;
      
      DebugVC50SSAlignSymImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this.offset = offset;
      }
      
      public DebugVC50SymbolIterator getSymbolIterator()
      {
        return new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, offset, getSubsectionSize());
      }
    }
    
    class DebugVC50SSSrcLnSegImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSSrcLnSeg
    {
      DebugVC50SSSrcLnSegImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSSrcModuleImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSSrcModule
    {
      private int offset;
      private short cFile;
      private short cSeg;
      private MemoizedObject baseSrcFiles;
      private MemoizedObject segOffsets;
      private MemoizedObject segs;
      
      DebugVC50SSSrcModuleImpl(short ssType, short iMod, int ssSize, final int offset)
      {
        super(ssType, iMod, ssSize, offset);
        
        this.offset = offset;
        this$1.seek(offset);
        cFile = this$1.readShort();
        cSeg = this$1.readShort();
        
        baseSrcFiles = new MemoizedObject()
        {
          public Object computeValue()
          {
            int[] offsets = new int[getNumSourceFiles()];
            this$1.seek(offset + 4);
            for (int i = 0; i < getNumSourceFiles(); i++) {
              offsets[i] = (offset + this$1.readInt());
            }
            COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModFileDescImpl[] res = new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModFileDescImpl[offsets.length];
            for (int i = 0; i < res.length; i++) {
              res[i] = new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModFileDescImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, offsets[i], offset);
            }
            return res;
          }
        };
        segOffsets = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4 * (getNumSourceFiles() + 1));
            int[] res = new int[2 * getNumCodeSegments()];
            for (int i = 0; i < 2 * getNumCodeSegments(); i++) {
              res[i] = this$1.readInt();
            }
            return res;
          }
        };
        segs = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4 * (getNumSourceFiles() + 1) + 8 * getNumCodeSegments());
            short[] res = new short[getNumCodeSegments()];
            for (int i = 0; i < getNumCodeSegments(); i++) {
              res[i] = this$1.readShort();
            }
            return res;
          }
        };
      }
      
      public int getNumSourceFiles()
      {
        return cFile & 0xFFFF;
      }
      
      public int getNumCodeSegments()
      {
        return cSeg & 0xFFFF;
      }
      
      public DebugVC50SrcModFileDesc getSourceFileDesc(int i)
      {
        return ((COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModFileDescImpl[])(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModFileDescImpl[])baseSrcFiles.getValue())[i];
      }
      
      public int getSegmentStartOffset(int i)
      {
        return ((int[])(int[])segOffsets.getValue())[(2 * i)];
      }
      
      public int getSegmentEndOffset(int i)
      {
        return ((int[])(int[])segOffsets.getValue())[(2 * i + 1)];
      }
      
      public int getSegment(int i)
      {
        return ((short[])(short[])segs.getValue())[i] & 0xFFFF;
      }
    }
    
    class DebugVC50SrcModFileDescImpl
      implements DebugVC50SrcModFileDesc
    {
      private short cSeg;
      private MemoizedObject baseSrcLn;
      private MemoizedObject segOffsets;
      private MemoizedObject name;
      
      DebugVC50SrcModFileDescImpl(final int offset, final int baseOffset)
      {
        this$1.seek(offset);
        cSeg = this$1.readShort();
        
        baseSrcLn = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4);
            int[] offsets = new int[getNumCodeSegments()];
            for (int i = 0; i < getNumCodeSegments(); i++) {
              offsets[i] = (baseOffset + this$1.readInt());
            }
            COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModLineNumberMapImpl[] res = new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModLineNumberMapImpl[getNumCodeSegments()];
            for (int i = 0; i < getNumCodeSegments(); i++) {
              res[i] = new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModLineNumberMapImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, offsets[i]);
            }
            return res;
          }
        };
        segOffsets = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4 * (getNumCodeSegments() + 1));
            int[] res = new int[2 * getNumCodeSegments()];
            for (int i = 0; i < 2 * getNumCodeSegments(); i++) {
              res[i] = this$1.readInt();
            }
            return res;
          }
        };
        name = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4 + 12 * getNumCodeSegments());
            
            int cbName = this$1.readByte() & 0xFF;
            byte[] res = new byte[cbName];
            this$1.readBytes(res);
            try
            {
              return new String(res, "US-ASCII");
            }
            catch (UnsupportedEncodingException e)
            {
              throw new COFFException(e);
            }
          }
        };
      }
      
      public int getNumCodeSegments()
      {
        return cSeg & 0xFFFF;
      }
      
      public DebugVC50SrcModLineNumberMap getLineNumberMap(int i)
      {
        return ((COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModLineNumberMapImpl[])(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SrcModLineNumberMapImpl[])baseSrcLn.getValue())[i];
      }
      
      public int getSegmentStartOffset(int i)
      {
        return ((int[])(int[])segOffsets.getValue())[(2 * i)];
      }
      
      public int getSegmentEndOffset(int i)
      {
        return ((int[])(int[])segOffsets.getValue())[(2 * i + 1)];
      }
      
      public String getSourceFileName()
      {
        return (String)name.getValue();
      }
    }
    
    class DebugVC50SrcModLineNumberMapImpl
      implements DebugVC50SrcModLineNumberMap
    {
      private short seg;
      private short cPair;
      private MemoizedObject offsets;
      private MemoizedObject lineNumbers;
      
      DebugVC50SrcModLineNumberMapImpl(final int offset)
      {
        this$1.seek(offset);
        seg = this$1.readShort();
        cPair = this$1.readShort();
        offsets = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4);
            int[] res = new int[getNumSourceLinePairs()];
            for (int i = 0; i < getNumSourceLinePairs(); i++) {
              res[i] = this$1.readInt();
            }
            return res;
          }
        };
        lineNumbers = new MemoizedObject()
        {
          public Object computeValue()
          {
            this$1.seek(offset + 4 * (getNumSourceLinePairs() + 1));
            short[] res = new short[getNumSourceLinePairs()];
            for (int i = 0; i < getNumSourceLinePairs(); i++) {
              res[i] = this$1.readShort();
            }
            return res;
          }
        };
      }
      
      public int getSegment()
      {
        return seg;
      }
      
      public int getNumSourceLinePairs()
      {
        return cPair;
      }
      
      public int getCodeOffset(int i)
      {
        return ((int[])(int[])offsets.getValue())[i];
      }
      
      public int getLineNumber(int i)
      {
        return ((short[])(short[])lineNumbers.getValue())[i] & 0xFFFF;
      }
    }
    
    class DebugVC50SSLibrariesImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSLibraries
    {
      DebugVC50SSLibrariesImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSSymbolBaseImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSSymbolBase
    {
      private int offset;
      private short symHash;
      private short addrHash;
      private int cbSymbol;
      private int cbSymHash;
      private int cbAddrHash;
      private static final int HEADER_SIZE = 16;
      
      DebugVC50SSSymbolBaseImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this.offset = offset;
        this$1.seek(offset);
        symHash = this$1.readShort();
        addrHash = this$1.readShort();
        cbSymbol = this$1.readInt();
        cbSymHash = this$1.readInt();
        cbAddrHash = this$1.readInt();
      }
      
      public short getSymHashIndex()
      {
        return symHash;
      }
      
      public short getAddrHashIndex()
      {
        return addrHash;
      }
      
      public int getSymTabSize()
      {
        return cbSymbol;
      }
      
      public int getSymHashSize()
      {
        return cbSymHash;
      }
      
      public int getAddrHashSize()
      {
        return cbAddrHash;
      }
      
      public DebugVC50SymbolIterator getSymbolIterator()
      {
        return new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, offset + 16, cbSymbol);
      }
    }
    
    class DebugVC50SSGlobalSymImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SSSymbolBaseImpl
      implements DebugVC50SSGlobalSym
    {
      DebugVC50SSGlobalSymImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSGlobalPubImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SSSymbolBaseImpl
      implements DebugVC50SSGlobalPub
    {
      DebugVC50SSGlobalPubImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSGlobalTypesImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSGlobalTypes
    {
      private int offset;
      private int cType;
      
      DebugVC50SSGlobalTypesImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this.offset = offset;
        this$1.seek(offset);
        this$1.readInt();
        cType = this$1.readInt();
      }
      
      public int getNumTypes()
      {
        return cType;
      }
      
      public int getTypeOffset(int i)
      {
        this$1.seek(offset + 4 * (i + 2));
        return this$1.readInt() + offsetOfFirstType();
      }
      
      public DebugVC50TypeIterator getTypeIterator()
      {
        return new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50TypeIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, this, offsetOfFirstType(), cType);
      }
      
      private int offsetOfFirstType()
      {
        return offset + 4 * (getNumTypes() + 2);
      }
    }
    
    class DebugVC50SSMPCImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSMPC
    {
      DebugVC50SSMPCImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSSegMapImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSSegMap
    {
      private short cSeg;
      private short cSegLog;
      private MemoizedObject segDescs;
      
      DebugVC50SSSegMapImpl(short ssType, short iMod, int ssSize, final int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this$1.seek(offset);
        cSeg = this$1.readShort();
        cSegLog = this$1.readShort();
        segDescs = new MemoizedObject()
        {
          public Object computeValue()
          {
            DebugVC50SegDesc[] descs = new DebugVC50SegDesc[cSeg];
            for (int i = 0; i < cSeg; i++) {
              descs[i] = new COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SegDescImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, offset + 4 + 20 * i);
            }
            return descs;
          }
        };
      }
      
      public short getNumSegDesc()
      {
        return cSeg;
      }
      
      public short getNumLogicalSegDesc()
      {
        return cSegLog;
      }
      
      public DebugVC50SegDesc getSegDesc(int i)
      {
        return ((DebugVC50SegDesc[])(DebugVC50SegDesc[])segDescs.getValue())[i];
      }
    }
    
    class DebugVC50SegDescImpl
      implements DebugVC50SegDesc
    {
      private short flags;
      private short ovl;
      private short group;
      private short frame;
      private short iSegName;
      private short iClassName;
      private int offset;
      private int cbSeg;
      
      DebugVC50SegDescImpl(int offset)
      {
        this$1.seek(offset);
        flags = this$1.readShort();
        ovl = this$1.readShort();
        group = this$1.readShort();
        frame = this$1.readShort();
        iSegName = this$1.readShort();
        iClassName = this$1.readShort();
        offset = this$1.readInt();
        cbSeg = this$1.readInt();
      }
      
      public short getFlags()
      {
        return flags;
      }
      
      public short getOverlayNum()
      {
        return ovl;
      }
      
      public short getGroup()
      {
        return group;
      }
      
      public short getFrame()
      {
        return frame;
      }
      
      public short getName()
      {
        return iSegName;
      }
      
      public short getClassName()
      {
        return iClassName;
      }
      
      public int getOffset()
      {
        return offset;
      }
      
      public int getSize()
      {
        return cbSeg;
      }
    }
    
    class DebugVC50SSSegNameImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSSegName
    {
      private int offset;
      private int size;
      private MemoizedObject names;
      
      DebugVC50SSSegNameImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this.offset = offset;
        size = ssSize;
        this$1.seek(offset);
        names = new MemoizedObject()
        {
          public Object computeValue()
          {
            int i = 0;
            List data = new ArrayList();
            while (i < size)
            {
              String s = this$1.readCString();
              data.add(s);
              i += s.length();
            }
            String[] res = new String[data.size()];
            res = (String[])data.toArray(res);
            return res;
          }
        };
      }
      
      public String getSegName(int i)
      {
        return ((String[])(String[])names.getValue())[i];
      }
    }
    
    class DebugVC50SSPreCompImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSPreComp
    {
      DebugVC50SSPreCompImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSOffsetMap16Impl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSOffsetMap16
    {
      DebugVC50SSOffsetMap16Impl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSOffsetMap32Impl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSOffsetMap32
    {
      DebugVC50SSOffsetMap32Impl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SSFileIndexImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SubsectionImpl
      implements DebugVC50SSFileIndex
    {
      private int offset;
      private short cMod;
      private short cRef;
      private MemoizedObject modStart;
      private MemoizedObject cRefCnt;
      private MemoizedObject nameRef;
      private MemoizedObject names;
      
      DebugVC50SSFileIndexImpl(short ssType, short iMod, int ssSize, final int offset)
      {
        super(ssType, iMod, ssSize, offset);
        this.offset = offset;
        this$1.seek(offset);
        cMod = this$1.readShort();
        cRef = this$1.readShort();
        modStart = new MemoizedObject()
        {
          public Object computeValue()
          {
            short[] vals = new short[cMod];
            this$1.seek(4 + offset);
            for (int i = 0; i < cMod; i++) {
              vals[i] = this$1.readShort();
            }
            return vals;
          }
        };
        cRefCnt = new MemoizedObject()
        {
          public Object computeValue()
          {
            short[] vals = new short[cMod];
            this$1.seek(4 + offset + 2 * cMod);
            for (int i = 0; i < cMod; i++) {
              vals[i] = this$1.readShort();
            }
            return vals;
          }
        };
        nameRef = new MemoizedObject()
        {
          public Object computeValue()
          {
            int[] vals = new int[cRef];
            this$1.seek(4 + offset + 4 * cMod);
            for (int i = 0; i < cMod; i++) {
              vals[i] = this$1.readInt();
            }
            return vals;
          }
        };
        names = new MemoizedObject()
        {
          public Object computeValue()
          {
            String[] vals = new String[cRef];
            for (int i = 0; i < cRef; i++) {
              vals[i] = this$1.readCString();
            }
            return vals;
          }
        };
      }
      
      public short getNumModules()
      {
        return cMod;
      }
      
      public short getNumReferences()
      {
        return cRef;
      }
      
      public short[] getModStart()
      {
        return (short[])modStart.getValue();
      }
      
      public short[] getRefCount()
      {
        return (short[])cRefCnt.getValue();
      }
      
      public int[] getNameRef()
      {
        return (int[])nameRef.getValue();
      }
      
      public String[] getNames()
      {
        return (String[])names.getValue();
      }
    }
    
    class DebugVC50SSStaticSymImpl
      extends COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.DebugVC50SSSymbolBaseImpl
      implements DebugVC50SSStaticSym
    {
      DebugVC50SSStaticSymImpl(short ssType, short iMod, int ssSize, int offset)
      {
        super(ssType, iMod, ssSize, offset);
      }
    }
    
    class DebugVC50SymbolIteratorImpl
      implements DebugVC50SymbolIterator
    {
      private int base;
      private int size;
      private int pos;
      private int curSymSize;
      private int curSymType;
      private static final int HEADER_SIZE = 4;
      
      DebugVC50SymbolIteratorImpl(int base, int size)
      {
        this(base, size, base);
      }
      
      private DebugVC50SymbolIteratorImpl(int base, int size, int pos)
      {
        this.base = base;
        this.size = size;
        this.pos = pos;
        this$1.seek(pos);
        curSymSize = (this$1.readShort() & 0xFFFF);
        curSymType = (this$1.readShort() & 0xFFFF);
      }
      
      public boolean done()
      {
        return pos == base + size;
      }
      
      public void next()
        throws NoSuchElementException
      {
        if (done()) {
          throw new NoSuchElementException("No more symbols");
        }
        pos += curSymSize + 2;
        this$1.seek(pos);
        curSymSize = (this$1.readShort() & 0xFFFF);
        curSymType = (this$1.readShort() & 0xFFFF);
      }
      
      public short getLength()
      {
        return (short)curSymSize;
      }
      
      public int getType()
      {
        return curSymType;
      }
      
      public int getOffset()
      {
        return pos + 4;
      }
      
      public byte getCompilerTargetProcessor()
      {
        symSeek(0);
        return this$1.readByte();
      }
      
      public int getCompilerFlags()
      {
        symSeek(1);
        int res = 0;
        for (int i = 0; i < 3; i++)
        {
          int b = this$1.readByte() & 0xFF;
          res = res << 8 | b;
        }
        return res;
      }
      
      public String getComplierVersion()
      {
        return readLengthPrefixedStringAt(4);
      }
      
      public int getRegisterSymbolType()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public short getRegisterEnum()
      {
        symSeek(4);
        return this$1.readShort();
      }
      
      public String getRegisterSymbolName()
      {
        return readLengthPrefixedStringAt(6);
      }
      
      public int getConstantType()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public int getConstantValueAsInt()
        throws DebugVC50WrongNumericTypeException
      {
        return readIntNumericLeafAt(4);
      }
      
      public long getConstantValueAsLong()
        throws DebugVC50WrongNumericTypeException
      {
        return readLongNumericLeafAt(4);
      }
      
      public float getConstantValueAsFloat()
        throws DebugVC50WrongNumericTypeException
      {
        return readFloatNumericLeafAt(4);
      }
      
      public double getConstantValueAsDouble()
        throws DebugVC50WrongNumericTypeException
      {
        return readDoubleNumericLeafAt(4);
      }
      
      public String getConstantName()
      {
        return readLengthPrefixedStringAt(4 + numericLeafLengthAt(4));
      }
      
      public int getUDTType()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public String getUDTName()
      {
        return readLengthPrefixedStringAt(4);
      }
      
      public int getSearchSymbolOffset()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public short getSearchSegment()
      {
        symSeek(4);
        return this$1.readShort();
      }
      
      public int getObjectCodeViewSignature()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public String getObjectName()
      {
        return readLengthPrefixedStringAt(4);
      }
      
      public int getManyRegType()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public byte getManyRegCount()
      {
        symSeek(4);
        return this$1.readByte();
      }
      
      public byte getManyRegRegister(int i)
      {
        symSeek(5 + i);
        return this$1.readByte();
      }
      
      public String getManyRegName()
      {
        return readLengthPrefixedStringAt(5 + getManyRegCount());
      }
      
      public short getReturnFlags()
      {
        symSeek(0);
        return this$1.readShort();
      }
      
      public byte getReturnStyle()
      {
        symSeek(2);
        return this$1.readByte();
      }
      
      public byte getReturnRegisterCount()
      {
        symSeek(3);
        return this$1.readByte();
      }
      
      public byte getReturnRegister(int i)
      {
        symSeek(4 + i);
        return this$1.readByte();
      }
      
      public void advanceToEntryThisSymbol()
      {
        this$1.seek(pos + 4);
        int tmpSymSize = this$1.readShort();
        int tmpSymType = this$1.readShort();
        if (Assert.ASSERTS_ENABLED) {
          Assert.that(pos + curSymSize + 2 == pos + 4 + tmpSymSize, "advanceToEntryThisSymbol needs more work");
        }
        pos += 4;
        curSymSize = tmpSymSize;
        curSymType = tmpSymType;
      }
      
      public int getBPRelOffset()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public int getBPRelType()
      {
        symSeek(4);
        return this$1.readInt();
      }
      
      public String getBPRelName()
      {
        return readLengthPrefixedStringAt(8);
      }
      
      public int getLGDataType()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public int getLGDataOffset()
      {
        symSeek(4);
        return this$1.readInt();
      }
      
      public short getLGDataSegment()
      {
        symSeek(8);
        return this$1.readShort();
      }
      
      public String getLGDataName()
      {
        return readLengthPrefixedStringAt(10);
      }
      
      public DebugVC50SymbolIterator getLGProcParent()
      {
        int offs = getLGProcParentOffset();
        if (offs == 0) {
          return null;
        }
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getLGProcParentOffset()
      {
        symSeek(0);
        int offs = this$1.readInt();
        if (offs == 0) {
          return 0;
        }
        return base + offs;
      }
      
      public DebugVC50SymbolIterator getLGProcEnd()
      {
        int offs = getLGProcEndOffset();
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getLGProcEndOffset()
      {
        symSeek(4);
        int offs = this$1.readInt();
        if (Assert.ASSERTS_ENABLED) {
          Assert.that(offs != 0, "should not have null end offset for procedure symbols");
        }
        return base + offs;
      }
      
      public DebugVC50SymbolIterator getLGProcNext()
      {
        int offs = getLGProcNextOffset();
        if (offs == 0) {
          return null;
        }
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getLGProcNextOffset()
      {
        symSeek(8);
        int offs = this$1.readInt();
        if (offs == 0) {
          return 0;
        }
        return base + offs;
      }
      
      public int getLGProcLength()
      {
        symSeek(12);
        return this$1.readInt();
      }
      
      public int getLGProcDebugStart()
      {
        symSeek(16);
        return this$1.readInt();
      }
      
      public int getLGProcDebugEnd()
      {
        symSeek(20);
        return this$1.readInt();
      }
      
      public int getLGProcType()
      {
        symSeek(24);
        return this$1.readInt();
      }
      
      public int getLGProcOffset()
      {
        symSeek(28);
        return this$1.readInt();
      }
      
      public short getLGProcSegment()
      {
        symSeek(32);
        return this$1.readShort();
      }
      
      public byte getLGProcFlags()
      {
        symSeek(34);
        return this$1.readByte();
      }
      
      public String getLGProcName()
      {
        return readLengthPrefixedStringAt(35);
      }
      
      public DebugVC50SymbolIterator getThunkParent()
      {
        int offs = getThunkParentOffset();
        if (offs == 0) {
          return null;
        }
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getThunkParentOffset()
      {
        symSeek(0);
        int offs = this$1.readInt();
        if (offs == 0) {
          return 0;
        }
        return base + offs;
      }
      
      public DebugVC50SymbolIterator getThunkEnd()
      {
        symSeek(4);
        int offs = this$1.readInt();
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getThunkEndOffset()
      {
        symSeek(4);
        int offs = this$1.readInt();
        if (Assert.ASSERTS_ENABLED) {
          Assert.that(offs != 0, "should not have null end offset for thunk symbols");
        }
        return base + offs;
      }
      
      public DebugVC50SymbolIterator getThunkNext()
      {
        int offs = getThunkNextOffset();
        if (offs == 0) {
          return null;
        }
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, base + offs);
      }
      
      public int getThunkNextOffset()
      {
        symSeek(8);
        int offs = this$1.readInt();
        if (offs == 0) {
          return 0;
        }
        return base + offs;
      }
      
      public int getThunkOffset()
      {
        symSeek(12);
        return this$1.readInt();
      }
      
      public short getThunkSegment()
      {
        symSeek(16);
        return this$1.readShort();
      }
      
      public short getThunkLength()
      {
        symSeek(18);
        return this$1.readShort();
      }
      
      public byte getThunkType()
      {
        symSeek(20);
        return this$1.readByte();
      }
      
      public String getThunkName()
      {
        return readLengthPrefixedStringAt(21);
      }
      
      public short getThunkAdjustorThisDelta()
      {
        symSeek(21 + lengthPrefixedStringLengthAt(21));
        return this$1.readShort();
      }
      
      public String getThunkAdjustorTargetName()
      {
        return readLengthPrefixedStringAt(23 + lengthPrefixedStringLengthAt(21));
      }
      
      public short getThunkVCallDisplacement()
      {
        symSeek(21 + lengthPrefixedStringLengthAt(21));
        return this$1.readShort();
      }
      
      public int getThunkPCodeOffset()
      {
        symSeek(21 + lengthPrefixedStringLengthAt(21));
        return this$1.readInt();
      }
      
      public short getThunkPCodeSegment()
      {
        symSeek(25 + lengthPrefixedStringLengthAt(21));
        return this$1.readShort();
      }
      
      public DebugVC50SymbolIterator getBlockParent()
      {
        int offs = getBlockParentOffset();
        if (offs == 0) {
          return null;
        }
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getBlockParentOffset()
      {
        symSeek(0);
        int offs = this$1.readInt();
        if (offs == 0) {
          return 0;
        }
        return base + offs;
      }
      
      public DebugVC50SymbolIterator getBlockEnd()
      {
        symSeek(4);
        int offs = this$1.readInt();
        return new DebugVC50SymbolIteratorImpl(COFFFileParser.COFFFileImpl.COFFHeaderImpl.DebugVC50Impl.this, base, size, offs);
      }
      
      public int getBlockEndOffset()
      {
        symSeek(4);
        int offs = this$1.readInt();
        if (Assert.ASSERTS_ENABLED) {
          Assert.that(offs != 0, "should not have null end offset for block symbols");
        }
        return base + offs;
      }
      
      public int getBlockLength()
      {
        symSeek(8);
        return this$1.readInt();
      }
      
      public int getBlockOffset()
      {
        symSeek(12);
        return this$1.readInt();
      }
      
      public short getBlockSegment()
      {
        symSeek(16);
        return this$1.readShort();
      }
      
      public String getBlockName()
      {
        return readLengthPrefixedStringAt(18);
      }
      
      public int getLabelOffset()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public short getLabelSegment()
      {
        symSeek(4);
        return this$1.readShort();
      }
      
      public byte getLabelFlags()
      {
        symSeek(6);
        return this$1.readByte();
      }
      
      public String getLabelName()
      {
        return readLengthPrefixedStringAt(7);
      }
      
      public int getChangeOffset()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public short getChangeSegment()
      {
        symSeek(4);
        return this$1.readShort();
      }
      
      public short getChangeModel()
      {
        symSeek(6);
        return this$1.readShort();
      }
      
      public int getVTableRoot()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public int getVTablePath()
      {
        symSeek(4);
        return this$1.readInt();
      }
      
      public int getVTableOffset()
      {
        symSeek(8);
        return this$1.readInt();
      }
      
      public short getVTableSegment()
      {
        symSeek(12);
        return this$1.readShort();
      }
      
      public int getRegRelOffset()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public int getRegRelType()
      {
        symSeek(4);
        return this$1.readInt();
      }
      
      public short getRegRelRegister()
      {
        symSeek(8);
        return this$1.readShort();
      }
      
      public String getRegRelName()
      {
        return readLengthPrefixedStringAt(10);
      }
      
      public int getLThreadType()
      {
        symSeek(0);
        return this$1.readInt();
      }
      
      public int getLThreadOffset()
      {
        symSeek(4);
        return this$1.readInt();
      }
      
      public short getLThreadSegment()
      {
        symSeek(8);
        return this$1.readShort
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd