diff -r a151135b0cf9 -r aa2539c91954 tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/source/SourceFormatter.java --- a/tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/engine/source/SourceFormatter.java Wed Sep 29 17:45:35 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,305 +0,0 @@ -/* - * 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 tags iterator is fixed, false if the - * contents of tags should go through - * SourceRule.mapNameToSource - * @return the trace string - */ - static String formatTrace(Trace trace, TraceFormattingRule traceRule, - TraceFormatType formatType, Iterator 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 tags iterator is fixed, false if the - * contents of tags should go through - * SourceRule.mapNameToSource - */ - private static void buildParameterList(Trace trace, - TraceFormattingRule format, StringBuffer data, - TraceFormatType formatType, Iterator tags, boolean fixedTags) { - - int count = trace.getParameterCount(); - - Iterator 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 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); - } - -}