* Description:  Definitions for the class CallstackDataParser

import com.nokia.s60tools.analyzetool.global.Util;

 * This class parses line of .dat file format and extracts callstack data. For

 * now this is a separate class but could eventually be moved into

 * ParseAnalyzeData after some re-factoring.

	/** True, if callstack reading for this BaseInfo is now complete. */

	/** Resulting callstack. */

	/**

	 * Number of remaining callstack elements expected to be processed with ALF

	 * or FRF.

	 */

	 * Cache for callstack items. Used when allocation fragment is parsed in the

	 * wrong order.

	private HashMap<Integer, List<AllocCallstack>> callstackCache = null;

	/**

	 * Constructor.

	 * 

	 * @param baseInfo

	 *            BaseInfo for the current alloc or free

	 * @param processInfo

	 *            ProcessInfo for the current alloc or free

	 */

	public CallstackDataParser(BaseInfo baseInfo, ProcessInfo processInfo) {

		if (processInfo == null || baseInfo == null

				|| processInfo.getProcessID() != baseInfo.getProcessID()) {

			throw new IllegalArgumentException(

					"BaseInfo and ProcessInfo are mandatory and must not be null; and the process ID of both must match."); //$NON-NLS-1$

		this.process = processInfo;

	 * Parses one line of &ltAT&gt statement.

	 * 

		if (aLine.indexOf(Constants.PREFIX) == -1) {

			// not a <AT> statement

		// String[] lineFragments = getLineFragments(aLine);

		int index = aLine.indexOf(Constants.PREFIX);

		String time = aLine.substring(0, index).trim();

		// // get logging time of line in microseconds

		// long logTime = Util.getLogTime(time);

		long logTime = Long.parseLong(time, 16);

		String usedString = aLine.substring(index, aLine.length());

		String[] lineFragments = usedString.split(" ");

		if (lineFragments.length < 5) {

			// not a valid <AT> statement for callstack processing

		if (baseInfo.getProcessID() != processID

				|| process.getProcessID() != processID) {

			// statement is not for current process id

		// the operation must match

		Constants.Operation op = Constants.Operation

				.toOperation(lineFragments[2]);

		if (!verifyOperation(op, baseInfo)) {

		// the memory address must match

		long memoryAddress = Long.parseLong(lineFragments[3], 16);

		if (baseInfo.getMemoryAddress() != memoryAddress) {

			return false;

		}

		case ALH:

		case FRH:

			ret = parseHeader(lineFragments, 5);

		case ALF:

			// fall through

		case FRF:

			ret = parseFragment(lineFragments, logTime);

		return ((aBaseInfo instanceof AllocInfo && (op == Constants.Operation.ALH || op == Constants.Operation.ALF)) || (aBaseInfo instanceof FreeInfo && (op == Constants.Operation.FRH || op == Constants.Operation.FRF)));

	// /**

	// * Returns the line fragments of the AT statement

	// *

	// * @param aLine

	// * the AT statement

	// * @return the line fragments separated by space

	// */

	// private String[] getLineFragments(final String aLine) {

	// int index = aLine.indexOf(Constants.PREFIX); // lines should be preceded

	//

	// if (index == -1) {

	// return new String[0];

	// }

	//

	// String usedString = (index == 0) ? aLine : aLine.substring(index, aLine

	// .length());

	//		return usedString.split(" "); //$NON-NLS-1$

	// }

	// /**

	// * Parses an ALC statement. This statement contains a complete callstack.

	// *

	// * @param fragments

	// * the line fragments of the statement to process

	// * @return true if statement is complete (this method will always return

	// * true)

	// */

	// private boolean parseAlloc(String[] fragments) {

	//

	// if (fragments.length > 5) {

	// createCallstack(fragments, process, callstack, 6);

	// }

	//

	// complete = true;

	// return true; // we are done; there are no fragments for this alloc

	// }

	 * Parses an ALH or FRH statement

	 * 

	 * @param fragments

	 *            the line fragments of the statement to process

	 * @param startIndex

	 *            index at which the callstack size is to be found

	 * @return true if callstack is complete, false if callstack fragment is

	 *         expected

					"Callstack list should still be empty when starting to process ALH or FRH"); //$NON-NLS-1$

			startIndex++;

			complete = true; // this header doesn't have callstacks - a bit

			// strange

	 * Parses an ALF or FRF callstack fragment

	 * 

	 * @param fragments

	 *            the line fragments of the statement to process

	private boolean parseFragment(String[] fragments, long logTime) {

		long time = process.getStartTime() + (logTime - process.getLogTime());

		int packetNumber = Integer.parseInt(fragments[4], 16);

			createCallstack(fragments, process, tmpCallstack, 5);

			if (remainingSize <= 0) {

	private void createCallstack(String[] fragments, ProcessInfo p,

			List<AllocCallstack> callstack, int startIndex) {

			DllLoad dllLoad = getDllForAddress(process, callstackElem

					.getMemoryAddress(), baseInfo.getTime());

	 * 

		if (packetNumber == 1) {

			// special case; this can be added to the end of the list straight

			// away

			// packages may come out of order; this is managed in the

			// callstackCache

			if (callstackCache == null) {

				callstackCache = new HashMap<Integer, List<AllocCallstack>>();

			callstackCache.put(packetNumber, tmpcallstack);

	 * Optimises internal callstack data structures. Should only be called after

	 * all data for this memory operation has been loaded (i.e. all fragments)

	public void finaliseCallstack() {

		if (callstackCache == null) {

			// nothing to do

		if (!complete) {

			throw new IllegalStateException(

					"callstack processing is not yet complete."); //$NON-NLS-1$

		if (callstack == null && callstackCache != null) {

			throw new IllegalStateException(); // first set of callstacks should

			// always be in callstacks

		if (callstackCache != null) {

			while (size != 0) {

				if (nextCallStacks != null) {

					size--;

				} // TODO else: missing callstack: shall we report it or log it?

	public List<AllocCallstack> getCallstack() {

		if (!complete) {

			throw new IllegalStateException(

					"Callstack has not been completely processed."); //$NON-NLS-1$

	 * Forces the callstack state to be set to complete. This should only be

	 * used when the end of file is encountered.

	public void forceComplete() {