--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/source/SourceFormatter.java Tue Aug 31 16:45:49 2010 +0300
@@ -0,0 +1,305 @@
+/*
+ * Copyright (c) 2010 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:
+ *
+ * Formatting rules are provided by Trace objects
+ *
+ */
+package com.nokia.tracecompiler.engine.source;
+
+import java.util.Iterator;
+
+import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;
+import com.nokia.tracecompiler.engine.rules.StateTraceRule;
+import com.nokia.tracecompiler.model.Trace;
+import com.nokia.tracecompiler.model.TraceParameter;
+import com.nokia.tracecompiler.plugin.TraceFormatConstants;
+import com.nokia.tracecompiler.plugin.TraceAPIFormatter.TraceFormatType;
+import com.nokia.tracecompiler.source.SourceConstants;
+import com.nokia.tracecompiler.source.SourceUtils;
+import com.nokia.tracecompiler.source.SymbianConstants;
+
+/**
+ * Static functions for source formatting
+ *
+ */
+public class SourceFormatter {
+
+ /**
+ * Value parameter name
+ */
+ public static final String VALUE_PARAMETER_NAME = "value"; //$NON-NLS-1$
+
+ /**
+ * Event start trace id parameter name
+ */
+ public static final String EVENT_START_TRACE_ID_PARAMETER_NAME = "linkToStart"; //$NON-NLS-1$
+
+ /**
+ * Constructor is hidden
+ */
+ private SourceFormatter() {
+ }
+
+ /**
+ * Formats a trace to string format using the formatting rule from the trace
+ *
+ * @param trace
+ * the trace
+ * @param formatType
+ * the type of format
+ * @return the trace string
+ */
+ public static String formatTrace(Trace trace, TraceFormatType formatType) {
+ return formatTrace(trace, null, formatType, null, false);
+ }
+
+ /**
+ * Formats a trace to string format
+ *
+ * @param trace
+ * the trace
+ * @param traceRule
+ * the formatting rule to be used
+ * @param formatType
+ * the type of format
+ * @param tags
+ * the tags for parameters or null if parameter names are used
+ * @param fixedTags
+ * true if the <i>tags</i> iterator is fixed, false if the
+ * contents of <i>tags</i> should go through
+ * <code>SourceRule.mapNameToSource</code>
+ * @return the trace string
+ */
+ static String formatTrace(Trace trace, TraceFormattingRule traceRule,
+ TraceFormatType formatType, Iterator<String> tags, boolean fixedTags) {
+ StringBuffer data = new StringBuffer();
+ String format = null;
+ if (traceRule == null) {
+
+ // If rule is not explicitly provided, it is fetched from the trace
+ traceRule = trace.getExtension(TraceFormattingRule.class);
+ if (traceRule == null) {
+
+ // If trace does not have a formatting rule, the project API's
+ // should implement default rule
+ traceRule = trace.getModel().getExtension(
+ TraceFormattingRule.class);
+ }
+ }
+ if (traceRule != null) {
+ format = traceRule.getFormat(trace, formatType);
+ }
+ if (format != null && traceRule != null) {
+ data.append(format);
+ data.append(SourceConstants.LINE_FEED);
+ buildParameterList(trace, traceRule, data, formatType, tags,
+ fixedTags);
+
+ String traceName = traceRule.mapNameToSource(trace);
+ String traceGroupName = trace.getGroup().getName();
+
+ // %NAME% is replaced with rule-mapped trace name
+ replaceData(data, traceName, TraceFormatConstants.NAME_FORMAT);
+
+ // %GROUP% is replaced with group name
+ replaceData(data, traceGroupName, TraceFormatConstants.GROUP_FORMAT);
+
+ // %TEXT% is replaced with trace text
+ replaceData(data, "\"" + trace.getTrace() //$NON-NLS-1$
+ + "\"", TraceFormatConstants.TEXT_FORMAT); //$NON-NLS-1$
+
+ // %FORMATTED_TRACE% is replaced with trace data
+ replaceData(data, trace.getTrace(),
+ TraceFormatConstants.FORMATTED_TRACE);
+
+ // Comment is inserted before the trace
+ int index = data.indexOf(TraceFormatConstants.COMMENT_FORMAT);
+ if (index >= 0) {
+ String comment = data.substring(index + 1);
+ data.delete(index, data.length());
+ data.insert(0, comment);
+ data.append(SourceConstants.LINE_FEED);
+ }
+ }
+
+ // If trace does not have formatting, it is not shown in source
+ return data.toString();
+ }
+
+ /**
+ * Adds the parameters to the data buffer
+ *
+ * @param trace
+ * the trace
+ * @param format
+ * the formatter from trace
+ * @param data
+ * the data buffer where the formatted data is stored
+ * @param formatType
+ * the format type to be applied
+ * @param tags
+ * the tags for parameters or null if parameter names are used
+ * @param fixedTags
+ * true if the <i>tags</i> iterator is fixed, false if the
+ * contents of <i>tags</i> should go through
+ * <code>SourceRule.mapNameToSource</code>
+ */
+ private static void buildParameterList(Trace trace,
+ TraceFormattingRule format, StringBuffer data,
+ TraceFormatType formatType, Iterator<String> tags, boolean fixedTags) {
+
+ int count = trace.getParameterCount();
+
+ Iterator<TraceParameter> itr = trace.getParameters();
+ StringBuffer paramList = new StringBuffer();
+ // Index is incremented by one for each parameter that has been added to
+ // source
+ int parameterIndex = 0;
+ while (itr.hasNext()) {
+ TraceParameter param = itr.next();
+ TraceParameterFormattingRule rule = param
+ .getExtension(TraceParameterFormattingRule.class);
+ String name;
+ // Count and name may be adjusted by rules provided by parameters
+ if (rule != null) {
+ boolean isInSource = rule.isShownInSource();
+ // If the parameter iterator is explicitly provided, the
+ // parameter name is fetched from it. If the parameter list does
+ // not have enough tags (for example when a new parameter is
+ // added to trace) the name of the parameter is used. The source
+ // rule is used to map the parameter name to correct format
+ if (isInSource) {
+ name = getTagWithoutMapping(tags, param);
+ addParameter(paramList, param, name, ++parameterIndex,
+ formatType);
+ } else {
+ // If the parameter is not shown in source, it is skipped
+ count--;
+ }
+ } else {
+ // If the parameter is not associated with a source rule, it is
+ // added without mapping
+ name = getTagWithoutMapping(tags, param);
+ addParameter(paramList, param, name, ++parameterIndex,
+ formatType);
+ }
+ }
+ // %PC% is replaced with adjusted parameter count
+ // In case of packed trace, the header engine does the count mapping
+ if (formatType != TraceFormatType.TRACE_PACKED) {
+ String val = format.mapParameterCountToSource(trace, count);
+
+ if (trace.getExtension(StateTraceRule.class) != null
+ && data.toString().startsWith("OstTraceState")) { //$NON-NLS-1$
+
+ // In case of State Trace macro value in trace macro is
+ // parameter count - 2
+ if (count > 1) {
+ val = String.valueOf(count - 2); // CodForChk_Dis_Magic
+ } else {
+ val = String.valueOf(count);
+ }
+ }
+ replaceData(data, val, TraceFormatConstants.PARAM_COUNT_FORMAT);
+ }
+ // %PARAMETERS% is replaced with parameter names
+ replaceData(data, paramList.toString(),
+ TraceFormatConstants.PARAMETERS_FORMAT);
+ }
+
+ /**
+ * Gets the name for a parameter without source rule mapping. If the tags
+ * iterator contains a valid entry, the name is fetched from it. If not, the
+ * parameter name is used instead.
+ *
+ * @param tags
+ * the list of tags
+ * @param param
+ * the parameter
+ * @return the parameter name
+ */
+ private static String getTagWithoutMapping(Iterator<String> tags,
+ TraceParameter param) {
+ String name;
+ // If the parameter iterator is explicitly provided, the
+ // parameter name is fetched from it
+ if (tags != null && tags.hasNext()) {
+ name = tags.next();
+ // The list may contain 0-length items to represent
+ // that that parameter name should be used instead
+ if (name == null || name.length() == 0) {
+ name = param.getName();
+ }
+ } else {
+ name = param.getName();
+ }
+ return name;
+ }
+
+ /**
+ * Adds a parameter to the parameter list
+ *
+ * @param paramList
+ * the parameter list
+ * @param param
+ * the parameter to be added
+ * @param name
+ * a name replacement for the parameter
+ * @param parameterIndex
+ * the index of the parameter
+ * @param formatType
+ * the type of the format
+ */
+ private static void addParameter(StringBuffer paramList,
+ TraceParameter param, String name, int parameterIndex,
+ TraceFormatType formatType) {
+ paramList.append(SourceConstants.PARAMETER_SEPARATOR);
+ if (formatType == TraceFormatType.HEADER) {
+ paramList.append(SourceUtils.mapParameterTypeToSymbianType(param));
+ paramList.append(SourceConstants.SPACE_CHAR);
+ paramList.append(SymbianConstants.PARAMETER_DECLARATION_PREFIX);
+ paramList.append(parameterIndex);
+ } else if (formatType == TraceFormatType.EMPTY_MACRO) {
+ paramList.append(SymbianConstants.PARAMETER_DECLARATION_PREFIX);
+ paramList.append(parameterIndex);
+ }
+ }
+
+ /**
+ * Replaces data from the stringbuffer
+ *
+ * @param data
+ * the data
+ * @param replaceData
+ * the data to be used
+ * @param replaceFormat
+ * the format to be replaced
+ */
+ private static void replaceData(StringBuffer data, String replaceData,
+ String replaceFormat) {
+ TraceCompilerEngineGlobals.getEvents().postInfoMessage(Messages.getString("SourceFormatter.replaceAllBeginText") + replaceFormat + Messages.getString("SourceFormatter.replaceAllMiddleText") + replaceData , null); //$NON-NLS-1$ //$NON-NLS-2$
+
+ int replaceOffset = 0;
+ do {
+ replaceOffset = data.indexOf(replaceFormat, replaceOffset);
+ if (replaceOffset >= 0) {
+ data.replace(replaceOffset, replaceOffset
+ + replaceFormat.length(), replaceData);
+ replaceOffset += replaceData.length();
+ }
+ } while (replaceOffset != -1);
+ }
+
+}