Back to index...

	/*
	* Copyright (c) 2001, 2013, 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.*;
	import java.io.File;

	class SDE {
	private static final int INIT_SIZE_FILE = 3;
	private static final int INIT_SIZE_LINE = 100;
	private static final int INIT_SIZE_STRATUM = 3;

	static final String BASE_STRATUM_NAME = "Java";

	/* for C capatibility */
	static final String NullString = null;

	private class FileTableRecord {
	int fileId;
	String sourceName;
	String sourcePath; // do not read - use accessor
	boolean isConverted = false;

	/**
	* Return the sourcePath, computing it if not set.
	* If set, convert '/' in the sourcePath to the
	* local file separator.
	*/
	String getSourcePath(ReferenceTypeImpl refType) {
	if (!isConverted) {
	if (sourcePath == null) {
	sourcePath = refType.baseSourceDir() + sourceName;
	} else {
	StringBuffer buf = new StringBuffer();
	for (int i = 0; i < sourcePath.length(); ++i) {
	char ch = sourcePath.charAt(i);
	if (ch == '/') {
	buf.append(File.separatorChar);
	} else {
	buf.append(ch);
	}
	}
	sourcePath = buf.toString();
	}
	isConverted = true;
	}
	return sourcePath;
	}
	}

	private class LineTableRecord {
	int jplsStart;
	int jplsEnd;
	int jplsLineInc;
	int njplsStart;
	int njplsEnd;
	int fileId;
	}

	private class StratumTableRecord {
	String id;
	int fileIndex;
	int lineIndex;
	}

	class Stratum {
	private final int sti; /* stratum index */

	private Stratum(int sti) {
	this.sti = sti;
	}

	String id() {
	return stratumTable[sti].id;
	}

	boolean isJava() {
	return sti == baseStratumIndex;
	}

	/**
	* Return all the sourceNames for this stratum.
	* Look from our starting fileIndex upto the starting
	* fileIndex of next stratum - can do this since there
	* is always a terminator stratum.
	* Default sourceName (the first one) must be first.
	*/
	List<String> sourceNames(ReferenceTypeImpl refType) {
	int i;
	int fileIndexStart = stratumTable[sti].fileIndex;
	/* one past end */
	int fileIndexEnd = stratumTable[sti+1].fileIndex;
	List<String> result = new ArrayList<String>(fileIndexEnd - fileIndexStart);
	for (i = fileIndexStart; i < fileIndexEnd; ++i) {
	result.add(fileTable[i].sourceName);
	}
	return result;
	}

	/**
	* Return all the sourcePaths for this stratum.
	* Look from our starting fileIndex upto the starting
	* fileIndex of next stratum - can do this since there
	* is always a terminator stratum.
	* Default sourcePath (the first one) must be first.
	*/
	List<String> sourcePaths(ReferenceTypeImpl refType) {
	int i;
	int fileIndexStart = stratumTable[sti].fileIndex;
	/* one past end */
	int fileIndexEnd = stratumTable[sti+1].fileIndex;
	List<String> result = new ArrayList<String>(fileIndexEnd - fileIndexStart);
	for (i = fileIndexStart; i < fileIndexEnd; ++i) {
	result.add(fileTable[i].getSourcePath(refType));
	}
	return result;
	}

	LineStratum lineStratum(ReferenceTypeImpl refType,
	int jplsLine) {
	int lti = stiLineTableIndex(sti, jplsLine);
	if (lti < 0) {
	return null;
	} else {
	return new LineStratum(sti, lti, refType,
	jplsLine);
	}
	}
	}

	class LineStratum {
	private final int sti; /* stratum index */
	private final int lti; /* line table index */
	private final ReferenceTypeImpl refType;
	private final int jplsLine;
	private String sourceName = null;
	private String sourcePath = null;

	private LineStratum(int sti, int lti,
	ReferenceTypeImpl refType,
	int jplsLine) {
	this.sti = sti;
	this.lti = lti;
	this.refType = refType;
	this.jplsLine = jplsLine;
	}

	public boolean equals(Object obj) {
	if (obj instanceof LineStratum) {
	LineStratum other = (LineStratum)obj;
	return (lti == other.lti) &&
	(sti == other.sti) &&
	(lineNumber() == other.lineNumber()) &&
	(refType.equals(other.refType));
	} else {
	return false;
	}
	}

	@Override
	public int hashCode() {
	return (lineNumber() * 17) ^ refType.hashCode();
	}

	int lineNumber() {
	return stiLineNumber(sti, lti, jplsLine);
	}

	/**
	* Fetch the source name and source path for
	* this line, converting or constructing
	* the source path if needed.
	*/
	void getSourceInfo() {
	if (sourceName != null) {
	// already done
	return;
	}
	int fti = stiFileTableIndex(sti, lti);
	if (fti == -1) {
	throw new InternalError(
	"Bad SourceDebugExtension, no matching source id " +
	lineTable[lti].fileId + " jplsLine: " + jplsLine);
	}
	FileTableRecord ftr = fileTable[fti];
	sourceName = ftr.sourceName;
	sourcePath = ftr.getSourcePath(refType);
	}

	String sourceName() {
	getSourceInfo();
	return sourceName;
	}

	String sourcePath() {
	getSourceInfo();
	return sourcePath;
	}
	}

	private FileTableRecord[] fileTable = null;
	private LineTableRecord[] lineTable = null;
	private StratumTableRecord[] stratumTable = null;

	private int fileIndex = 0;
	private int lineIndex = 0;
	private int stratumIndex = 0;
	private int currentFileId = 0;

	private int defaultStratumIndex = -1;
	private int baseStratumIndex = -2; /* so as not to match -1 above */
	private int sdePos = 0;

	final String sourceDebugExtension;
	String jplsFilename = null;
	String defaultStratumId = null;
	boolean isValid = false;

	SDE(String sourceDebugExtension) {
	this.sourceDebugExtension = sourceDebugExtension;
	decode();
	}

	SDE() {
	this.sourceDebugExtension = null;
	createProxyForAbsentSDE();
	}

	char sdePeek() {
	if (sdePos >= sourceDebugExtension.length()) {
	syntax();
	}
	return sourceDebugExtension.charAt(sdePos);
	}

	char sdeRead() {
	if (sdePos >= sourceDebugExtension.length()) {
	syntax();
	}
	return sourceDebugExtension.charAt(sdePos++);
	}

	void sdeAdvance() {
	sdePos++;
	}

	void syntax() {
	throw new InternalError("bad SourceDebugExtension syntax - position " +
	sdePos);
	}

	void syntax(String msg) {
	throw new InternalError("bad SourceDebugExtension syntax: " + msg);
	}

	void assureLineTableSize() {
	int len = lineTable == null? 0 : lineTable.length;
	if (lineIndex >= len) {
	int i;
	int newLen = len == 0? INIT_SIZE_LINE : len * 2;
	LineTableRecord[] newTable = new LineTableRecord[newLen];
	for (i = 0; i < len; ++i) {
	newTable[i] = lineTable[i];
	}
	for (; i < newLen; ++i) {
	newTable[i] = new LineTableRecord();
	}
	lineTable = newTable;
	}
	}

	void assureFileTableSize() {
	int len = fileTable == null? 0 : fileTable.length;
	if (fileIndex >= len) {
	int i;
	int newLen = len == 0? INIT_SIZE_FILE : len * 2;
	FileTableRecord[] newTable = new FileTableRecord[newLen];
	for (i = 0; i < len; ++i) {
	newTable[i] = fileTable[i];
	}
	for (; i < newLen; ++i) {
	newTable[i] = new FileTableRecord();
	}
	fileTable = newTable;
	}
	}

	void assureStratumTableSize() {
	int len = stratumTable == null? 0 : stratumTable.length;
	if (stratumIndex >= len) {
	int i;
	int newLen = len == 0? INIT_SIZE_STRATUM : len * 2;
	StratumTableRecord[] newTable = new StratumTableRecord[newLen];
	for (i = 0; i < len; ++i) {
	newTable[i] = stratumTable[i];
	}
	for (; i < newLen; ++i) {
	newTable[i] = new StratumTableRecord();
	}
	stratumTable = newTable;
	}
	}

	String readLine() {
	StringBuffer sb = new StringBuffer();
	char ch;

	ignoreWhite();
	while (((ch = sdeRead()) != '\n') && (ch != '\r')) {
	sb.append(ch);
	}
	// check for CR LF
	if ((ch == '\r') && (sdePeek() == '\n')) {
	sdeRead();
	}
	ignoreWhite(); // leading white
	return sb.toString();
	}

	private int defaultStratumTableIndex() {
	if ((defaultStratumIndex == -1) && (defaultStratumId != null)) {
	defaultStratumIndex =
	stratumTableIndex(defaultStratumId);
	}
	return defaultStratumIndex;
	}

	int stratumTableIndex(String stratumId) {
	int i;

	if (stratumId == null) {
	return defaultStratumTableIndex();
	}
	for (i = 0; i < (stratumIndex-1); ++i) {
	if (stratumTable[i].id.equals(stratumId)) {
	return i;
	}
	}
	return defaultStratumTableIndex();
	}

	Stratum stratum(String stratumID) {
	int sti = stratumTableIndex(stratumID);
	return new Stratum(sti);
	}

	List<String> availableStrata() {
	List<String> strata = new ArrayList<String>();

	for (int i = 0; i < (stratumIndex-1); ++i) {
	StratumTableRecord rec = stratumTable[i];
	strata.add(rec.id);
	}
	return strata;
	}

	/*****************************
	* below functions/methods are written to compile under either Java or C
	*
	* Needed support functions:
	* sdePeek()
	* sdeRead()
	* sdeAdvance()
	* readLine()
	* assureLineTableSize()
	* assureFileTableSize()
	* assureStratumTableSize()
	* syntax()
	*
	* stratumTableIndex(String)
	*
	* Needed support variables:
	* lineTable
	* lineIndex
	* fileTable
	* fileIndex
	* currentFileId
	*
	* Needed types:
	* String
	*
	* Needed constants:
	* NullString
	*/

	void ignoreWhite() {
	char ch;

	while (((ch = sdePeek()) == ' ') \|\| (ch == '\t')) {
	sdeAdvance();
	}
	}

	void ignoreLine() {
	char ch;

	while (((ch = sdeRead()) != '\n') && (ch != '\r')) {
	}
	/* check for CR LF */
	if ((ch == '\r') && (sdePeek() == '\n')) {
	sdeAdvance();
	}
	ignoreWhite(); /* leading white */
	}

	int readNumber() {
	int value = 0;
	char ch;

	ignoreWhite();
	while (((ch = sdePeek()) >= '0') && (ch <= '9')) {
	sdeAdvance();
	value = (value * 10) + ch - '0';
	}
	ignoreWhite();
	return value;
	}

	void storeFile(int fileId, String sourceName, String sourcePath) {
	assureFileTableSize();
	fileTable[fileIndex].fileId = fileId;
	fileTable[fileIndex].sourceName = sourceName;
	fileTable[fileIndex].sourcePath = sourcePath;
	++fileIndex;
	}

	void fileLine() {
	int hasAbsolute = 0; /* acts as boolean */
	int fileId;
	String sourceName;
	String sourcePath = null;

	/* is there an absolute filename? */
	if (sdePeek() == '+') {
	sdeAdvance();
	hasAbsolute = 1;
	}
	fileId = readNumber();
	sourceName = readLine();
	if (hasAbsolute == 1) {
	sourcePath = readLine();
	}

	storeFile(fileId, sourceName, sourcePath);
	}

	void storeLine(int jplsStart, int jplsEnd, int jplsLineInc,
	int njplsStart, int njplsEnd, int fileId) {
	assureLineTableSize();
	lineTable[lineIndex].jplsStart = jplsStart;
	lineTable[lineIndex].jplsEnd = jplsEnd;
	lineTable[lineIndex].jplsLineInc = jplsLineInc;
	lineTable[lineIndex].njplsStart = njplsStart;
	lineTable[lineIndex].njplsEnd = njplsEnd;
	lineTable[lineIndex].fileId = fileId;
	++lineIndex;
	}

	/**
	* Parse line translation info. Syntax is
	* <NJ-start-line> [ # <file-id> ] [ , <line-count> ] :
	* <J-start-line> [ , <line-increment> ] CR
	*/
	void lineLine() {
	int lineCount = 1;
	int lineIncrement = 1;
	int njplsStart;
	int jplsStart;

	njplsStart = readNumber();

	/* is there a fileID? */
	if (sdePeek() == '#') {
	sdeAdvance();
	currentFileId = readNumber();
	}

	/* is there a line count? */
	if (sdePeek() == ',') {
	sdeAdvance();
	lineCount = readNumber();
	}

	if (sdeRead() != ':') {
	syntax();
	}
	jplsStart = readNumber();
	if (sdePeek() == ',') {
	sdeAdvance();
	lineIncrement = readNumber();
	}
	ignoreLine(); /* flush the rest */

	storeLine(jplsStart,
	jplsStart + (lineCount * lineIncrement) -1,
	lineIncrement,
	njplsStart,
	njplsStart + lineCount -1,
	currentFileId);
	}

	/**
	* Until the next stratum section, everything after this
	* is in stratumId - so, store the current indicies.
	*/
	void storeStratum(String stratumId) {
	/* remove redundant strata */
	if (stratumIndex > 0) {
	if ((stratumTable[stratumIndex-1].fileIndex
	== fileIndex) &&
	(stratumTable[stratumIndex-1].lineIndex
	== lineIndex)) {
	/* nothing changed overwrite it */
	--stratumIndex;
	}
	}
	/* store the results */
	assureStratumTableSize();
	stratumTable[stratumIndex].id = stratumId;
	stratumTable[stratumIndex].fileIndex = fileIndex;
	stratumTable[stratumIndex].lineIndex = lineIndex;
	++stratumIndex;
	currentFileId = 0;
	}

	/**
	* The beginning of a stratum's info
	*/
	void stratumSection() {
	storeStratum(readLine());
	}

	void fileSection() {
	ignoreLine();
	while (sdePeek() != '*') {
	fileLine();
	}
	}

	void lineSection() {
	ignoreLine();
	while (sdePeek() != '*') {
	lineLine();
	}
	}

	/**
	* Ignore a section we don't know about.
	*/
	void ignoreSection() {
	ignoreLine();
	while (sdePeek() != '*') {
	ignoreLine();
	}
	}

	/**
	* A base "Java" stratum is always available, though
	* it is not in the SourceDebugExtension.
	* Create the base stratum.
	*/
	void createJavaStratum() {
	baseStratumIndex = stratumIndex;
	storeStratum(BASE_STRATUM_NAME);
	storeFile(1, jplsFilename, NullString);
	/* JPL line numbers cannot exceed 65535 */
	storeLine(1, 65536, 1, 1, 65536, 1);
	storeStratum("Aux"); /* in case they don't declare */
	}

	/**
	* Decode a SourceDebugExtension which is in SourceMap format.
	* This is the entry point into the recursive descent parser.
	*/
	void decode() {
	/* check for "SMAP" - allow EOF if not ours */
	if ((sourceDebugExtension.length() < 4) \|\|
	(sdeRead() != 'S') \|\|
	(sdeRead() != 'M') \|\|
	(sdeRead() != 'A') \|\|
	(sdeRead() != 'P')) {
	return; /* not our info */
	}
	ignoreLine(); /* flush the rest */
	jplsFilename = readLine();
	defaultStratumId = readLine();
	createJavaStratum();
	while (true) {
	if (sdeRead() != '*') {
	syntax();
	}
	switch (sdeRead()) {
	case 'S':
	stratumSection();
	break;
	case 'F':
	fileSection();
	break;
	case 'L':
	lineSection();
	break;
	case 'E':
	/* set end points */
	storeStratum("terminator");
	isValid = true;
	return;
	default:
	ignoreSection();
	}
	}
	}

	void createProxyForAbsentSDE() {
	jplsFilename = null;
	defaultStratumId = BASE_STRATUM_NAME;
	defaultStratumIndex = stratumIndex;
	createJavaStratum();
	storeStratum("terminator");
	}

	/*************** query functions *********************/

	private int stiLineTableIndex(int sti, int jplsLine) {
	int i;
	int lineIndexStart;
	int lineIndexEnd;

	lineIndexStart = stratumTable[sti].lineIndex;
	/* one past end */
	lineIndexEnd = stratumTable[sti+1].lineIndex;
	for (i = lineIndexStart; i < lineIndexEnd; ++i) {
	if ((jplsLine >= lineTable[i].jplsStart) &&
	(jplsLine <= lineTable[i].jplsEnd)) {
	return i;
	}
	}
	return -1;
	}

	private int stiLineNumber(int sti, int lti, int jplsLine) {
	return lineTable[lti].njplsStart +
	(((jplsLine - lineTable[lti].jplsStart) /
	lineTable[lti].jplsLineInc));
	}

	private int fileTableIndex(int sti, int fileId) {
	int i;
	int fileIndexStart = stratumTable[sti].fileIndex;
	/* one past end */
	int fileIndexEnd = stratumTable[sti+1].fileIndex;
	for (i = fileIndexStart; i < fileIndexEnd; ++i) {
	if (fileTable[i].fileId == fileId) {
	return i;
	}
	}
	return -1;
	}

	private int stiFileTableIndex(int sti, int lti) {
	return fileTableIndex(sti, lineTable[lti].fileId);
	}

	boolean isValid() {
	return isValid;
	}
	}

Back to index...