flash.tools.debugger.concrete.ScriptText Maven / Gradle / Ivy

Go to download
/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package flash.tools.debugger.concrete;

/**
 * Contains the text contents of a script and is able
 * to map line numbers to specific regions of the script (i.e. string)
 */
public class ScriptText
{
	private final String m_text;
	private int[]  m_lineMap;  // a 2-d array [2i] = startIndex and [2i+1] = endIndex for line i

	public ScriptText(String text)
	{
		m_text = text;
	}

	/* return a string containing the line number requested */
	public String getLine(int lineNum) 
	{
		determineLines();

		int index = lineNum-1;
		if (index < 0)
			; // throw 

		/* look into our mapping array */
		int start = m_lineMap[2*index];
		int end = m_lineMap[(2*index)+1];

		String s = m_text.substring(start, end);
		return s;
	}

	/* line count in module */
	public int getLineCount()
	{
		determineLines();
		return m_lineMap.length/2;
	}

	/**
	 * Build mapping tables based on the line count of 
	 * the given source string.
	 * 
	 * These tables allow us to compute starting and 
	 * ending locations of each line of the source file.
	 * 
	 * The assumption using this technique is that most
	 * lines of the source files will never be accessed 
	 * thus we only incur the overhead of 8 bytes 
	 * (start & end) per line, plus the actual string 
	 * contents each line a line is requested.
	 * 
	 * Thus we need  8 * num_files * num_lines_per_file bytes
	 * for all these maps.
	 * 
	 * For example, say each file is 1000 lines and we have
	 * 400 source files;  We would consume 3.2MB.  With 
	 * each request we would allocate an additional 20+
	 * bytes for the string (assuming a 20B avg line length).
	 * 
	 * Allocating each line individually we would consume
	 * 1000 * 400 * 20 = 8MB.
	 * 
	 * It is debatable whether this scheme is more efficient
	 * than actually builing an array of Strings to contain
	 * the lines, but gut feel says it is ;)
	 */
	private synchronized void determineLines()
	{
		// determineLines() is done on demand in order to avoid wasting time
		// doing this for every file; so check if we've already done it
		if (m_lineMap != null)
			return;

		int count = lineCountFor(m_text) + 1; // add 1 to the line count to handle newline on last line

		// allocated our maps (really a 2-d array where [i] = startAt & [i+1] = endAt )
		m_lineMap = new int[(2*count)+1];

		int i = 0;
		int lineNum = 0;
		int startAt = 0;
		int endAt = 0;
		int length = m_text.length();
		char c = '\0';
		while(i < length)
		{
			/* end of line */
			c = m_text.charAt(i++);
			if (c == '\n' || c == '\r')
			{
				m_lineMap[2*lineNum] = startAt;
				m_lineMap[(2*lineNum)+1] = endAt;
				lineNum++;

				/* do we need to chew a CR LF combo */
				if (c == '\r' && i < length && m_text.charAt(i) == '\n')
					i++;

				startAt = i;
				endAt = i;
			}
			else 
				endAt++;
		}

		/* need to add the last line? */
		if (startAt != endAt)
		{
			/* add the last line if not empty */
			m_lineMap[2*lineNum] = startAt;
			m_lineMap[(2*lineNum)+1] = endAt;
		}
	}
 
	/**
	 * Count the number of lines within this string.
	 */
	public static int lineCountFor(String s)
	{
		int i = 0;
		int lineNum = 0;
		int length = s.length();
		char c = '\0';
		while(i < length)
		{
			/* end of line */
			c = s.charAt(i++);
			if (c == '\n' || c == '\r')
			{
				lineNum++;

				/* do we need to chew a CR LF combo */
				if (c == '\r' && i < length && s.charAt(i) == '\n')
					i++;
			}
		}
		return lineNum;
	}
}