diff -r 14dc2103a631 -r ed1c9f64298a trace/tracebuilder/com.nokia.tracebuilder/src/com/nokia/tracebuilder/source/SourceContext.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/trace/tracebuilder/com.nokia.tracebuilder/src/com/nokia/tracebuilder/source/SourceContext.java	Wed Jun 23 14:35:40 2010 +0300
@@ -0,0 +1,320 @@
+/*
+* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+* Source context is a representation of a range of source code
+*
+*/
+package com.nokia.tracebuilder.source;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+
+/**
+ * Source context is a representation of a range of source code. For example a
+ * function in source code could be represented with a context that has the name
+ * of the function
+ * 
+ */
+public class SourceContext extends SourceLocationBase implements ParsedType {
+
+	/**
+	 * No proposal
+	 */
+	public static final int NONE = 0; // CodForChk_Dis_Magic
+
+	/**
+	 * Start of function proposal type
+	 */
+	public static final int START_OF_FUNCTION = 1; // CodForChk_Dis_Magic
+
+	/**
+	 * End of function proposal type
+	 */
+	public static final int END_OF_FUNCTION = 2; // CodForChk_Dis_Magic
+
+	/**
+	 * Full selection proposal type
+	 */
+	public static final int FULL_SELECTION = 3; // CodForChk_Dis_Magic
+
+	/**
+	 * Class name
+	 */
+	private String className;
+
+	/**
+	 * Function name
+	 */
+	private String functionName;
+
+	/**
+	 * Index to start of parameters
+	 */
+	private int parameterStart;
+
+	/**
+	 * List of return types
+	 */
+	private ArrayList<String> returnTypes;
+
+	/**
+	 * Creates a new SourceContext starting from given offset
+	 * 
+	 * @param parser
+	 *            the parser owning this context
+	 * @param offset
+	 *            the offset
+	 */
+	SourceContext(SourceParser parser, int offset) {
+		super(parser, offset);
+	}
+
+	/**
+	 * Gets the class name of this context
+	 * 
+	 * @return the class name
+	 */
+	public String getClassName() {
+		return className;
+	}
+
+	/**
+	 * Gets the function name of this context
+	 * 
+	 * @return the function name
+	 */
+	public String getFunctionName() {
+		return functionName;
+	}
+
+	/**
+	 * Sets the class name. If the class name contains pointer or reference
+	 * characters, they are added to the return statements list
+	 * 
+	 * @param name
+	 *            the new class name
+	 */
+	void setClassName(String name) {
+		className = removePtrAndRef(name);
+	}
+
+	/**
+	 * Sets the function name. If the function name contains pointer or
+	 * reference characters, they are added to the return statements list
+	 * 
+	 * @param name
+	 *            the new function name
+	 */
+	void setFunctionName(String name) {
+		functionName = removePtrAndRef(name);
+	}
+
+	/**
+	 * Removes the * and & characters from the given tag and adds them as return
+	 * modifiers
+	 * 
+	 * @param name
+	 *            the name
+	 * @return the name with * and & removed
+	 */
+	private String removePtrAndRef(String name) {
+		String retval = name;
+		if (name != null) {
+			int start = 0;
+			int end = name.length();
+			boolean found = true;
+			while (start < end && found) {
+				char c = name.charAt(start);
+				if (c == '*' || c == '&') {
+					addReturnModifier(c);
+					start++;
+				} else {
+					found = false;
+				}
+			}
+			found = true;
+			while (end > start && found) {
+				char c = name.charAt(end - 1);
+				if (c == '*' || c == '&') {
+					addReturnModifier(c);
+					end--;
+				} else {
+					found = false;
+				}
+			}
+			retval = name.substring(start, end);
+		}
+		return retval;
+	}
+
+	/**
+	 * Sets the index for start of parameters
+	 * 
+	 * @param index
+	 *            the index
+	 */
+	void setParametersStartIndex(int index) {
+		parameterStart = index;
+	}
+
+	/**
+	 * Adds a return type string to the context
+	 * 
+	 * @param type
+	 *            the return type
+	 */
+	void addReturnType(String type) {
+		// Constructors and destructor do not have return types
+		if (className != null && functionName!= null && !className.equals(functionName)
+				&& !functionName.equals(SourceConstants.TILDE + className)) {
+			type = removePtrAndRef(type);
+			if (type.length() > 0) {
+				if (returnTypes == null) {
+					returnTypes = new ArrayList<String>();
+				}
+				returnTypes.add(type);
+			}
+		}
+	}
+
+	/**
+	 * Adds a return type modifier to the list of return types
+	 * 
+	 * @param c
+	 *            the modifier
+	 */
+	private void addReturnModifier(char c) {
+		if (returnTypes == null) {
+			returnTypes = new ArrayList<String>();
+		}
+		returnTypes.add(String.valueOf(c));
+	}
+
+	/**
+	 * Gets the return types of this context
+	 * 
+	 * @return the return types
+	 */
+	Iterator<String> getReturnTypes() {
+		List<String> list;
+		if (returnTypes != null) {
+			list = returnTypes;
+		} else {
+			list = Collections.emptyList();
+		}
+		return list.iterator();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.nokia.tracebuilder.source.ParsedType#hasQualifier(java.lang.String)
+	 */
+	public boolean hasQualifier(String type) {
+		// All types and qualifiers are in the returnTypes list
+		return typeEquals(type);
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.nokia.tracebuilder.source.ParsedType#typeEquals(java.lang.String)
+	 */
+	public boolean typeEquals(String type) {
+		return (returnTypes != null && returnTypes.contains(type));
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see com.nokia.tracebuilder.source.ParsedType#isPointer()
+	 */
+	public boolean isPointer() {
+		boolean retval = false;
+		if (returnTypes != null) {
+			for (int i = 0; i < returnTypes.size() && !retval; i++) {
+				if (returnTypes.get(i).equals(SourceConstants.ASTERISK)) {
+					retval = true;
+				}
+			}
+		}
+		return retval;
+	}
+
+	/**
+	 * Checks if return types list contains "void"
+	 * 
+	 * @return true if void, false if not
+	 */
+	public boolean isVoid() {
+		return (returnTypes == null || returnTypes
+				.contains(SourceConstants.VOID));
+	}
+
+	/**
+	 * Parses the parameters of this source context
+	 * 
+	 * @param parameterList
+	 *            the list where the parameters are stored
+	 * @throws SourceParserException
+	 *             if parsing fails
+	 */
+	public void parseParameters(List<SourceParameter> parameterList)
+			throws SourceParserException {
+		if (getParser() != null) {
+			getParser().parseFunctionParameters(parameterStart, parameterList);
+		} else {
+			throw new SourceParserException(
+					SourceErrorCodes.CONTEXT_MISSING_OWNER);
+		}
+	}
+
+	/**
+	 * Parses the return statements of this source context
+	 * 
+	 * @param returnList
+	 *            the list where the return values are stored
+	 * @throws SourceParserException
+	 *             if parsing fails
+	 */
+	public void parseReturnValues(List<SourceReturn> returnList)
+			throws SourceParserException {
+		if (getParser() != null) {
+			getParser().parseReturnValues(this, returnList);
+		} else {
+			throw new SourceParserException(
+					SourceErrorCodes.CONTEXT_MISSING_OWNER);
+		}
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * 
+	 * @see java.lang.Object#toString()
+	 */
+	@Override
+	public String toString() {
+		StringBuffer sb = new StringBuffer();
+		if (className != null) {
+			sb.append(getClassName());
+		}
+		sb.append("::"); //$NON-NLS-1$
+		sb.append(getFunctionName());
+		return sb.toString();
+	}
+
+}