/* * Copyright (c) 2000, 2008, Oracle and/or its affiliates. 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.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.sun.tools.jdi; import com.sun.jdi.*; import java.util.List;import java.util.Map;import java.util.Iterator;import java.util.ListIterator;import java.util.HashMap;import java.util.ArrayList;import java.util.Collections;import java.lang.ref.SoftReference; /** * Represents methods with method bodies. * That is, non-native non-abstract methods. * Private to MethodImpl. */public class ConcreteMethodImpl extends MethodImpl {     /*     * A subset of the line number info that is softly cached     */    static private class SoftLocationXRefs {        final String stratumID;   // The stratum of this information        final Map<Integer, List<Location>> lineMapper;     // Maps line number to location(s)        final List<Location> lineLocations; // List of locations ordered by code index         /*         * Note: these do not necessarily correspond to         * the line numbers of the first and last elements         * in the lineLocations list. Use these only for bounds         * checking and with lineMapper.         */        final int lowestLine;        final int highestLine;         SoftLocationXRefs(String stratumID, Map<Integer, List<Location>> lineMapper, List<Location> lineLocations,                     int lowestLine, int highestLine) {            this.stratumID = stratumID;            this.lineMapper = Collections.unmodifiableMap(lineMapper);            this.lineLocations =                Collections.unmodifiableList(lineLocations);            this.lowestLine = lowestLine;            this.highestLine = highestLine;        }    }     private Location location = null;    private SoftReference<SoftLocationXRefs> softBaseLocationXRefsRef;    private SoftReference<SoftLocationXRefs> softOtherLocationXRefsRef;    private SoftReference<List<LocalVariable>> variablesRef = null;    private boolean absentVariableInformation = false;    private long firstIndex = -1;    private long lastIndex = -1;    private SoftReference<byte[]> bytecodesRef = null;    private int argSlotCount = -1;     ConcreteMethodImpl(VirtualMachine vm, ReferenceTypeImpl declaringType,                       long ref,                       String name, String signature,                       String genericSignature, int modifiers) {         // The generic signature is set when this is created        super(vm, declaringType, ref, name, signature,              genericSignature, modifiers);    }     public Location location() {        if (location == null) {            getBaseLocations();        }        return location;    }     List<Location> sourceNameFilter(List<Location> list,                          SDE.Stratum stratum,                          String sourceName)                            throws AbsentInformationException {        if (sourceName == null) {            return list;        } else {            /* needs sourceName filteration */            List<Location> locs = new ArrayList<Location>();            for (Location loc : list) {                if (((LocationImpl)loc).sourceName(stratum).equals(sourceName)) {                    locs.add(loc);                }            }            return locs;        }    }     List<Location> allLineLocations(SDE.Stratum stratum,                          String sourceName)                            throws AbsentInformationException {        List<Location> lineLocations = getLocations(stratum).lineLocations;         if (lineLocations.size() == 0) {            throw new AbsentInformationException();        }         return Collections.unmodifiableList(          sourceNameFilter(lineLocations, stratum, sourceName));    }     List<Location> locationsOfLine(SDE.Stratum stratum,                         String sourceName,                         int lineNumber)                            throws AbsentInformationException {        SoftLocationXRefs info = getLocations(stratum);         if (info.lineLocations.size() == 0) {            throw new AbsentInformationException();        }         /*         * Find the locations which match the line number         * passed in.         */        List<Location> list = info.lineMapper.get(new Integer(lineNumber));         if (list == null) {            list = new ArrayList<Location>(0);        }        return Collections.unmodifiableList(          sourceNameFilter(list, stratum, sourceName));    }      public Location locationOfCodeIndex(long codeIndex) {        if (firstIndex == -1) {            getBaseLocations();        }         /*         * Check for invalid code index.         */        if (codeIndex < firstIndex || codeIndex > lastIndex) {            return null;        }         return new LocationImpl(virtualMachine(), this, codeIndex);    }      LineInfo codeIndexToLineInfo(SDE.Stratum stratum,                                 long codeIndex) {        if (firstIndex == -1) {            getBaseLocations();        }         /*         * Check for invalid code index.         */        if (codeIndex < firstIndex || codeIndex > lastIndex) {            throw new InternalError(                    "Location with invalid code index");        }         List<Location> lineLocations = getLocations(stratum).lineLocations;         /*         * Check for absent line numbers.         */        if (lineLocations.size() == 0) {            return super.codeIndexToLineInfo(stratum, codeIndex);        }         Iterator iter = lineLocations.iterator();        /*         * Treat code before the beginning of the first line table         * entry as part of the first line.  javac will generate         * code like this for some local classes. This "prolog"         * code contains assignments from locals in the enclosing         * scope to synthetic fields in the local class.  Same for         * other language prolog code.         */        LocationImpl bestMatch = (LocationImpl)iter.next();        while (iter.hasNext()) {            LocationImpl current = (LocationImpl)iter.next();            if (current.codeIndex() > codeIndex) {                break;            }            bestMatch = current;        }        return bestMatch.getLineInfo(stratum);    }      public List<LocalVariable> variables() throws AbsentInformationException {        return getVariables();    }     public List<LocalVariable> variablesByName(String name) throws AbsentInformationException {        List<LocalVariable> variables = getVariables();         List<LocalVariable> retList = new ArrayList<LocalVariable>(2);        Iterator iter = variables.iterator();        while(iter.hasNext()) {            LocalVariable variable = (LocalVariable)iter.next();            if (variable.name().equals(name)) {                retList.add(variable);            }        }        return retList;    }     public List<LocalVariable> arguments() throws AbsentInformationException {        List<LocalVariable> variables = getVariables();         List<LocalVariable> retList = new ArrayList<LocalVariable>(variables.size());        Iterator iter = variables.iterator();        while(iter.hasNext()) {            LocalVariable variable = (LocalVariable)iter.next();            if (variable.isArgument()) {                retList.add(variable);            }        }        return retList;    }     public byte[] bytecodes() {        byte[] bytecodes = (bytecodesRef == null) ? null :                                     bytecodesRef.get();        if (bytecodes == null) {            try {                bytecodes = JDWP.Method.Bytecodes.                                 process(vm, declaringType, ref).bytes;            } catch (JDWPException exc) {                throw exc.toJDIException();            }            bytecodesRef = new SoftReference<byte[]>(bytecodes);        }        /*         * Arrays are always modifiable, so it is a little unsafe         * to return the cached bytecodes directly; instead, we         * make a clone at the cost of using more memory.         */        return bytecodes.clone();    }     int argSlotCount() throws AbsentInformationException {        if (argSlotCount == -1) {            getVariables();        }        return argSlotCount;    }     private SoftLocationXRefs getLocations(SDE.Stratum stratum) {        if (stratum.isJava()) {            return getBaseLocations();        }        String stratumID = stratum.id();        SoftLocationXRefs info =            (softOtherLocationXRefsRef == null) ? null :               softOtherLocationXRefsRef.get();        if (info != null && info.stratumID.equals(stratumID)) {            return info;        }         List<Location> lineLocations = new ArrayList<Location>();        Map<Integer, List<Location>> lineMapper = new HashMap<Integer, List<Location>>();        int lowestLine = -1;        int highestLine = -1;        SDE.LineStratum lastLineStratum = null;        SDE.Stratum baseStratum =            declaringType.stratum(SDE.BASE_STRATUM_NAME);        Iterator it = getBaseLocations().lineLocations.iterator();        while(it.hasNext()) {            LocationImpl loc = (LocationImpl)it.next();            int baseLineNumber = loc.lineNumber(baseStratum);            SDE.LineStratum lineStratum =                  stratum.lineStratum(declaringType,                                      baseLineNumber);             if (lineStratum == null) {                // location not mapped in this stratum                continue;            }             int lineNumber = lineStratum.lineNumber();             // remove unmapped and dup lines            if ((lineNumber != -1) &&                          (!lineStratum.equals(lastLineStratum))) {                lastLineStratum = lineStratum;                 // Remember the largest/smallest line number                if (lineNumber > highestLine) {                    highestLine = lineNumber;                }                if ((lineNumber < lowestLine) || (lowestLine == -1)) {                    lowestLine = lineNumber;                }                 loc.addStratumLineInfo(                  new StratumLineInfo(stratumID,                                      lineNumber,                                      lineStratum.sourceName(),                                      lineStratum.sourcePath()));                 // Add to the location list                lineLocations.add(loc);                 // Add to the line -> locations map                Integer key = new Integer(lineNumber);                List<Location> mappedLocs = lineMapper.get(key);                if (mappedLocs == null) {                    mappedLocs = new ArrayList<Location>(1);                    lineMapper.put(key, mappedLocs);                }                mappedLocs.add(loc);            }        }         info = new SoftLocationXRefs(stratumID,                                lineMapper, lineLocations,                                lowestLine, highestLine);        softOtherLocationXRefsRef = new SoftReference<SoftLocationXRefs>(info);        return info;    }     private SoftLocationXRefs getBaseLocations() {        SoftLocationXRefs info = (softBaseLocationXRefsRef == null) ? null :                                     softBaseLocationXRefsRef.get();        if (info != null) {            return info;        }         JDWP.Method.LineTable lntab = null;        try {            lntab = JDWP.Method.LineTable.process(vm, declaringType, ref);        } catch (JDWPException exc) {            /*             * Note: the absent info error shouldn't happen here             * because the first and last index are always available.             */            throw exc.toJDIException();        }         int count  = lntab.lines.length;         List<Location> lineLocations = new ArrayList<Location>(count);        Map<Integer, List<Location>>lineMapper = new HashMap<Integer, List<Location>>();        int lowestLine = -1;        int highestLine = -1;        for (int i = 0; i < count; i++) {            long bci = lntab.lines[i].lineCodeIndex;            int lineNumber = lntab.lines[i].lineNumber;             /*             * Some compilers will point multiple consecutive             * lines at the same location. We need to choose             * one of them so that we can consistently map back             * and forth between line and location. So we choose             * to record only the last line entry at a particular             * location.             */            if ((i + 1 == count) || (bci != lntab.lines[i+1].lineCodeIndex)) {                // Remember the largest/smallest line number                if (lineNumber > highestLine) {                    highestLine = lineNumber;                }                if ((lineNumber < lowestLine) || (lowestLine == -1)) {                    lowestLine = lineNumber;                }                LocationImpl loc =                    new LocationImpl(virtualMachine(), this, bci);                loc.addBaseLineInfo(                    new BaseLineInfo(lineNumber, declaringType));                 // Add to the location list                lineLocations.add(loc);                 // Add to the line -> locations map                Integer key = new Integer(lineNumber);                List<Location> mappedLocs = lineMapper.get(key);                if (mappedLocs == null) {                    mappedLocs = new ArrayList<Location>(1);                    lineMapper.put(key, mappedLocs);                }                mappedLocs.add(loc);            }        }         /*         * firstIndex, lastIndex, and startLocation need to be         * retrieved only once since they are strongly referenced.         */        if (location == null) {            firstIndex = lntab.start;            lastIndex = lntab.end;            /*             * The startLocation is the first one in the             * location list if we have one;             * otherwise, we construct a location for a             * method start with no line info             */            if (count > 0) {                location = lineLocations.get(0);            } else {                location = new LocationImpl(virtualMachine(), this,                                            firstIndex);            }        }         info = new SoftLocationXRefs(SDE.BASE_STRATUM_NAME,                                lineMapper, lineLocations,                                lowestLine, highestLine);        softBaseLocationXRefsRef = new SoftReference<SoftLocationXRefs>(info);        return info;    }     private List<LocalVariable> getVariables1_4() throws AbsentInformationException {        JDWP.Method.VariableTable vartab = null;        try {            vartab = JDWP.Method.VariableTable.                                     process(vm, declaringType, ref);        } catch (JDWPException exc) {            if (exc.errorCode() == JDWP.Error.ABSENT_INFORMATION) {                absentVariableInformation = true;                throw new AbsentInformationException();            } else {                throw exc.toJDIException();            }        }         // Get the number of slots used by argument variables        argSlotCount = vartab.argCnt;        int count = vartab.slots.length;        List<LocalVariable> variables = new ArrayList<LocalVariable>(count);        for (int i=0; i<count; i++) {            JDWP.Method.VariableTable.SlotInfo si = vartab.slots[i];             /*             * Skip "this*" entries because they are never real             * variables from the JLS perspective.             */            if (!si.name.startsWith("this$") && !si.name.equals("this")) {                Location scopeStart = new LocationImpl(virtualMachine(),                                                       this, si.codeIndex);                Location scopeEnd =                    new LocationImpl(virtualMachine(), this,                                     si.codeIndex + si.length - 1);                LocalVariable variable =                    new LocalVariableImpl(virtualMachine(), this,                                          si.slot, scopeStart, scopeEnd,                                          si.name, si.signature, null);                // Add to the variable list                variables.add(variable);            }        }        return variables;    }     private List<LocalVariable> getVariables1() throws AbsentInformationException {         if (!vm.canGet1_5LanguageFeatures()) {            return getVariables1_4();        }         JDWP.Method.VariableTableWithGeneric vartab = null;        try {            vartab = JDWP.Method.VariableTableWithGeneric.                                     process(vm, declaringType, ref);        } catch (JDWPException exc) {            if (exc.errorCode() == JDWP.Error.ABSENT_INFORMATION) {                absentVariableInformation = true;                throw new AbsentInformationException();            } else {                throw exc.toJDIException();            }        } 

Lines 1–500 of 545. Load more