diff -r a151135b0cf9 -r aa2539c91954 tracesrv/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/rules/RuleUtils.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/tracesrv/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/rules/RuleUtils.java	Fri Oct 08 14:56:39 2010 +0300
@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 2009 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:
+ *
+ * Utility functions for rules package
+ *
+ */
+package com.nokia.tracecompiler.engine.rules;
+
+import java.util.Iterator;
+import java.util.List;
+
+import com.nokia.tracecompiler.engine.TraceCompilerEngineConfiguration;
+import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;
+import com.nokia.tracecompiler.model.Trace;
+import com.nokia.tracecompiler.model.TraceCompilerException;
+import com.nokia.tracecompiler.model.TraceConstantTable;
+import com.nokia.tracecompiler.model.TraceModel;
+import com.nokia.tracecompiler.model.TraceModelExtension;
+import com.nokia.tracecompiler.model.TraceObjectUtils;
+import com.nokia.tracecompiler.model.TraceParameter;
+import com.nokia.tracecompiler.source.ParsedType;
+import com.nokia.tracecompiler.source.SourceContext;
+import com.nokia.tracecompiler.source.SourceParserException;
+import com.nokia.tracecompiler.source.SourceReturn;
+import com.nokia.tracecompiler.source.TypeMapping;
+
+/**
+ * Utility functions for rules package
+ * 
+ */
+public final class RuleUtils {
+
+	/**
+	 * Entry-exit template
+	 */
+	public static final int TYPE_ENTRY_EXIT = 0; // CodForChk_Dis_Magic
+
+	/**
+	 * Start-stop event template
+	 */
+	public static final int TYPE_PERF_EVENT = 1; // CodForChk_Dis_Magic
+
+	/**
+	 * State trace template
+	 */
+	public static final int TYPE_STATE_TRACE = 2; // CodForChk_Dis_Magic
+
+	/**
+	 * Trace name format base
+	 */
+	static final String NAME_FORMAT_BASE = "{$CN}_{$FN}"; //$NON-NLS-1$
+
+	/**
+	 * Trace text format base
+	 */
+	static final String TEXT_FORMAT_BASE = "{$cn}::{$fn}"; //$NON-NLS-1$
+
+	/**
+	 * Template titles
+	 */
+	private static final String[] ENTRY_TEMPLATE_TITLES = {
+			Messages.getString("RuleUtils.FunctionEntryTitle"), //$NON-NLS-1$
+			Messages.getString("RuleUtils.PerformanceEventTitle"), //$NON-NLS-1$
+			Messages.getString("RuleUtils.StateTraceTitle"), //$NON-NLS-1$
+	};
+
+	/**
+	 * Entry name prefixes
+	 */
+	public static final String[] ENTRY_NAME_PREFIXES = { "", //$NON-NLS-1$
+			"EVENT_", //$NON-NLS-1$
+			"STATE_" //$NON-NLS-1$
+	};
+
+	/**
+	 * Entry name suffixes
+	 */
+	public static final String[] ENTRY_NAME_SUFFIXES = { "_ENTRY", //$NON-NLS-1$
+			"_START", //$NON-NLS-1$
+			"" //$NON-NLS-1$
+	};
+
+	/**
+	 * Exit name prefixes
+	 */
+	private static final String[] EXIT_NAME_PREFIXES = { "", //$NON-NLS-1$
+			"EVENT_", //$NON-NLS-1$
+			"" //$NON-NLS-1$
+	};
+
+	/**
+	 * Exit name suffixes
+	 */
+	public static final String[] EXIT_NAME_SUFFIXES = { "_EXIT", //$NON-NLS-1$
+			"_STOP", //$NON-NLS-1$
+			"" //$NON-NLS-1$
+	};
+
+	/**
+	 * Gets an entry template title
+	 * 
+	 * @param type
+	 *            the template type
+	 * @return the template title
+	 */
+	static String getEntryTemplateTitle(int type) {
+		return ENTRY_TEMPLATE_TITLES[type];
+	}
+
+	/**
+	 * Creates exit name from entry name
+	 * 
+	 * @param entryName
+	 *            the entry name
+	 * @param type
+	 *            the type of entry
+	 * @return the exit name
+	 */
+	static String createExitName(String entryName, int type) {
+		// Strips the duplicate modifier from the name
+		entryName = TraceObjectUtils.removeDuplicateModifier(entryName);
+		StringBuffer sb = new StringBuffer();
+		if (entryName.startsWith(ENTRY_NAME_PREFIXES[type])) {
+			entryName = entryName.substring(ENTRY_NAME_PREFIXES[type].length());
+		}
+		if (entryName.endsWith(ENTRY_NAME_SUFFIXES[type])) {
+			entryName = entryName.substring(0, entryName.length()
+					- ENTRY_NAME_SUFFIXES[type].length());
+		}
+		sb.append(EXIT_NAME_PREFIXES[type]);
+		sb.append(entryName);
+		sb.append(EXIT_NAME_SUFFIXES[type]);
+		return sb.toString();
+	}
+
+	/**
+	 * Creates an entry trace name format from type
+	 * 
+	 * @param type
+	 *            the trace format type
+	 * @return the trace name format
+	 */
+	public static String createEntryTraceNameFormat(int type) {
+		StringBuffer sb = new StringBuffer();
+		if (type == TYPE_PERF_EVENT || type == TYPE_STATE_TRACE) {
+			sb.append(NAME_FORMAT_BASE);
+		} else {
+			sb.append(ENTRY_NAME_PREFIXES[type]);
+			sb.append(NAME_FORMAT_BASE);
+			sb.append(ENTRY_NAME_SUFFIXES[type]);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Creates an exit trace name format based on type
+	 * 
+	 * @param type
+	 *            the format type
+	 * @return the trace name format
+	 */
+	public static String createExitTraceNameFormat(int type) {
+		StringBuffer sb = new StringBuffer();
+		sb.append(EXIT_NAME_PREFIXES[type]);
+		sb.append(NAME_FORMAT_BASE);
+		sb.append(EXIT_NAME_SUFFIXES[type]);
+		return sb.toString();
+	}
+
+	/**
+	 * Gets the return statements from current context from the context manager.
+	 * 
+	 * @param returnStatements
+	 *            the list where the return statements are stored
+	 */
+	static void getCurrentContextReturns(List<SourceReturn> returnStatements) {
+		SourceContext context = TraceCompilerEngineGlobals.getSourceContextManager()
+				.getContext();
+		if (context != null) {
+			try {
+				context.parseReturnValues(returnStatements);
+			} catch (SourceParserException e) {
+				String msg = Messages
+						.getString("RuleUtils.FailedToParseReturnValues"); //$NON-NLS-1$
+				String cname = context.getClassName();
+				String source;
+				if (cname != null) {
+					source = cname + "::" + context.getFunctionName(); //$NON-NLS-1$;
+				} else {
+					source = context.getFunctionName();
+				}
+				TraceCompilerEngineGlobals.getEvents().postErrorMessage(msg, source,
+						true);
+			}
+		} else {
+			if (TraceCompilerEngineConfiguration.ASSERTIONS_ENABLED) {
+				TraceCompilerEngineGlobals.getEvents().postAssertionFailed(
+						"Function return not in function", null); //$NON-NLS-1$
+			}
+		}
+	}
+
+	/**
+	 * Checks if the function is static. Currently this is just dummy, checking
+	 * that the class name exists and the function name is not New / NewL /
+	 * NewLC
+	 * 
+	 * @param context
+	 *            the context to be checked
+	 * @return true if static, false if not
+	 */
+	static boolean isStaticFunction(SourceContext context) {
+		boolean retval;
+		if (context.getClassName() == null) {
+			retval = true;
+		} else {
+			String fname = context.getFunctionName();
+			if (fname.equals("New") //$NON-NLS-1$
+					|| fname.equals("NewL") //$NON-NLS-1$
+					|| fname.equals("NewLC") //$NON-NLS-1$
+			) {
+				retval = true;
+			} else {
+				retval = false;
+			}
+		}
+		return retval;
+	}
+
+	/**
+	 * Locates a constant table based on type definition parsed from source
+	 * 
+	 * @param model
+	 *            the trace model
+	 * @param type
+	 *            the parameter type
+	 * @return the constant table or null if not found
+	 */
+	static TraceConstantTable findConstantTableByType(TraceModel model,
+			ParsedType type) {
+		Iterator<TraceConstantTable> tables = model.getConstantTables();
+		TraceConstantTable foundTable = null;
+		while (tables.hasNext() && foundTable == null) {
+			TraceConstantTable table = tables.next();
+			if (type.typeEquals(table.getName())) {
+				foundTable = table;
+			}
+		}
+		return foundTable;
+	}
+
+	/**
+	 * Creates a parameter based on TypeMapping definition
+	 * 
+	 * @param owner
+	 *            the parameter owner
+	 * @param name
+	 *            the parameter name
+	 * @param type
+	 *            the type mapping
+	 * @return the parameter
+	 * @throws TraceCompilerException
+	 *             if parameter cannot be created
+	 */
+	static TraceParameter createParameterFromType(Trace owner, String name,
+			TypeMapping type) throws TraceCompilerException {
+		int id = owner.getNextParameterID();
+		owner.getModel().getVerifier().checkTraceParameterProperties(owner,
+				null, id, name, type.type);
+		TraceModelExtension[] extensions = null;
+		if (type.needsCasting || type.valueToPointer
+				|| type.type.equals(TraceParameter.TIME)) {
+			extensions = new TraceModelExtension[1];
+			extensions[0] = new ParameterTypeMappingRule(type);
+		}
+		TraceParameter parameter = owner.getModel().getFactory()
+				.createTraceParameter(owner, id, name, type.type, extensions);
+		return parameter;
+	}
+
+	/**
+	 * Creates a parameter object from constant table
+	 * 
+	 * @param owner
+	 *            the parameter owner
+	 * @param name
+	 *            the name for the parameter
+	 * @param table
+	 *            the constant table
+	 * @return the parameter
+	 * @throws TraceCompilerException
+	 *             if parameter cannot be created
+	 */
+	static TraceParameter createParameterFromConstantTable(Trace owner,
+			String name, TraceConstantTable table) throws TraceCompilerException {
+		int id = owner.getNextParameterID();
+		owner.getModel().getVerifier().checkTraceParameterProperties(owner,
+				null, id, name, table.getType());
+		// Constant tables need a cast to constant table type
+		TypeMapping type = new TypeMapping(table.getType());
+		type.needsCasting = true;
+		TraceModelExtension[] extensions = new TraceModelExtension[1];
+		extensions[0] = new ParameterTypeMappingRule(type);
+		return owner.getModel().getFactory().createTraceParameter(owner, id,
+				name, table.getName(), extensions);
+	}
+
+}