diff -r a151135b0cf9 -r aa2539c91954 tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/source/SourceUtils.java
--- a/tracefw/tracecompiler/src/com.nokia.tracecompiler/src/com/nokia/tracecompiler/source/SourceUtils.java Wed Sep 29 17:45:35 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,1146 +0,0 @@
-/*
-* 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:
-*
-* Static utility functions related to source files
-*
-*/
-package com.nokia.tracecompiler.source;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import com.nokia.tracecompiler.engine.TraceCompilerEngineGlobals;
-import com.nokia.tracecompiler.engine.TraceCompilerEngineErrorCodes.StringErrorParameters;
-import com.nokia.tracecompiler.engine.TraceCompilerEngineErrorCodes.TraceCompilerErrorCode;
-import com.nokia.tracecompiler.model.TraceCompilerException;
-import com.nokia.tracecompiler.model.TraceConstantTable;
-import com.nokia.tracecompiler.model.TraceParameter;
-import com.nokia.tracecompiler.rules.ArrayParameterRule;
-
-/**
- * Static utility functions related to source files
- *
- */
-public class SourceUtils {
-
- /**
- * Tag for array types
- */
- private static final String ARRAY_TAG = "[]"; //$NON-NLS-1$
-
- /**
- * Start tag for printf format specifier
- */
- private static final String START_TAG = "%"; //$NON-NLS-1$
-
- /**
- * Regular expression optional element tag
- */
- private static final String OPTIONAL_TAG = "?"; //$NON-NLS-1$
-
- /**
- * Optional parameter pattern. Quoted from Wikipedia:
- *
- * Parameter can be omitted or can be: 'n$' Where n is the number
- * of the parameter to display using this format specifier, allowing the
- * parameters provided to be output multiple times, using varying format
- * specifiers or in different orders. This is a POSIX extension and not in
- * C99.
- *
- * This has not been implemented -> Currently format specifier count must
- * match parameter count
- */
- private final static String PARAMETER_PATTERN = "(\\d+\\$)"; //$NON-NLS-1$
-
- /**
- * Optional flags pattern. Quoted from Wikipedia:
- *
- * Flags can be zero or more (in any order) of:
- *
- * - '+' : Causes printf to always denote the sign '+' or '-' of a number
- * (the default is to omit the sign for positive numbers). Only applicable
- * to numeric types.
- *
- '-' : Causes printf to left-align the output of this placeholder (the
- * default is to right-align the output).
- *
- '#' : Alternate form. For 'g' and 'G', trailing zeros are not
- * removed. For 'f', 'F', 'e', 'E', 'g', 'G', the output always contains a
- * decimal point. For 'o', 'x', and 'X', a 0, 0x, and 0X, respectively, is
- * prepended to non-zero numbers.
- *
- ' ' : Causes printf to left-pad the output with spaces until the
- * required length of output is attained. If combined with '0' (see below),
- * it will cause the sign to become a space when positive, but the remaining
- * characters will be zero-padded
- *
- '0' : Causes printf to use '0' (instead of spaces) to left fill a
- * fixed length field. For example (assume i = 3) printf("%2d", i) results
- * in " 3", while printf("%02d", i) results in "03"
- *
- *
- */
- private final static String FLAGS_PATTERN = "([-+# 0])"; //$NON-NLS-1$
-
- /**
- * Optional width pattern. Quoted from Wikipedia:
- *
- * Width can be omitted or be any of:
- *
- * - a number : Causes printf to pad the output of this placeholder with
- * spaces until it is at least number characters wide. If number has a
- * leading '0', then padding is done with '0' characters.
- *
- '*' : Causes printf to pad the output until it is n characters wide,
- * where n is an integer value stored in the a function argument just
- * preceding that represented by the modified type. For example
- * printf("%*d", 5, 10) will result in "10" being printed with a width of
- * 5.
- *
- *
- *
- * '*' has not been implemented -> Currently format specifier count must
- * match parameter count
- */
- private final static String WIDTH_PATTERN = "(\\d+|\\*)"; //$NON-NLS-1$
-
- /**
- * Optional precision pattern. Quoted from Wikipedia:
- *
- * Precision can be omitted or be any of:
- *
- * - a number : For non-integral numeric types, causes the decimal portion
- * of the output to be expressed in at least number digits. For the string
- * type, causes the output to be truncated at number characters.
- *
- '*' : Same as the above, but uses an integer value in the intaken
- * argument to determine the number of decimal places or maximum string
- * length. For example, printf("%.*s", 3, "abcdef") will result in "abc"
- * being printed.
- *
- * If the precision is zero, nothing is printed for the
- * corresponding argument.
- *
- * '*' has not been implemented -> Currently format specifier count must
- * match parameter count
- */
- private final static String PRECISION_PATTERN = "(\\.(\\d+|\\*))"; //$NON-NLS-1$
-
- /**
- * Optional length pattern. Quoted from Wikipedia:
- *
- * Length can be omitted or be any of:
- *
- * - 'hh' : For integer types, causes printf to expect an int sized
- * integer argument which was promoted from a char.
- *
- 'h' : For integer types, causes printf to expect a int sized integer
- * argument which was promoted from a short.
- *
- 'l' : (ell) For integer types, causes printf to expect a long sized
- * integer argument.
- *
- 'll' : (ell ell) For integer types, causes printf to expect a long
- * long sized integer argument.
- *
- 'L' : For floating point types, causes printf to expect a long double
- * argument.
- *
- 'z' : For integer types, causes printf to expect a size_t sized
- * integer argument.
- *
- 'j' : For integer types, causes printf to expect a intmax_t sized
- * integer argument.
- *
- 't' : For integer types, causes printf to expect a ptrdiff_t sized
- * integer argument.
- *
- *
- */
- private final static String LENGTH_PATTERN = "([lh]?[hHlLZjt])"; //$NON-NLS-1$
-
- /**
- * Type pattern. Quoted from Wikipedia:
- *
- * type can be any of:
- *
- * - 'd', 'i' : Print an int as a signed decimal number. '%d' and '%i' are
- * synonymous for output, but are different when used with scanf() for
- * input.
- *
- 'u' : Print decimal unsigned int.
- *
- 'f', 'F' : Print a double in normal (fixed-point) notation.
- *
- 'e', 'E' : Print a double value in standard form ([-]d.ddd
- * e[+/-]ddd).
- *
- 'g', 'G' : Print a double in either normal or exponential notation,
- * whichever is more appropriate for its magnitude. 'g' uses lower-case
- * letters, 'G' uses upper-case letters. This type differs slightly from
- * fixed-point notation in that insignificant zeroes to the right of the
- * decimal point are not included. Also, the decimal point is not included
- * on whole numbers.
- *
- 'x', 'X' : Print an unsigned int as a hexadecimal number. 'x' uses
- * lower-case letters and 'X' uses upper-case.
- *
- 'o' : Print an unsigned int in octal.
- *
- 's' : Print a character string.
- *
- 'c' : Print a char (character).
- *
- 'p' : Print a void * (pointer to void) in an implementation-defined
- * format.
- *
- 'n' : Write number of characters successfully written so far into an
- * integer pointer parameter.
- *
- '%' : Print a literal '%' character (this type doesn't accept any
- * flags, width, precision or length).
- *
- *
- *
- * The pattern itself accepts all characters and the validity check is done
- * in {@link #mapFormatToParameterType mapFormatToType}
- */
- private final static String TYPE_PATTERN = "([a-zA-Z%])"; //$NON-NLS-1$
-
- /**
- * Regular expression pattern for printf
- *
- * %[parameter][flags][width][.precision][length]type
- */
- private static final String STANDARD_PRINTF_PATTERN = PARAMETER_PATTERN
- + OPTIONAL_TAG + FLAGS_PATTERN + OPTIONAL_TAG + WIDTH_PATTERN
- + OPTIONAL_TAG + PRECISION_PATTERN + OPTIONAL_TAG + LENGTH_PATTERN
- + OPTIONAL_TAG + TYPE_PATTERN;
-
- /**
- * Regular expression pattern for Open System Trace printf extensions
- * %{Type}, %{Array[]}
- */
- private static final String EXTENSION_PRINTF_PATTERN = "\\{[\\w_]+(\\[\\])?\\}"; //$NON-NLS-1$
-
- /**
- * Regular expression pattern for printf
- */
- public static final String PRINTF_PATTERN = START_TAG + "((" //$NON-NLS-1$
- + STANDARD_PRINTF_PATTERN + ")|(" //$NON-NLS-1$
- + EXTENSION_PRINTF_PATTERN + "))"; //$NON-NLS-1$
-
- /**
- * The pattern for printf-formatted trace text
- */
- public final static Pattern traceTextPattern = Pattern
- .compile(PRINTF_PATTERN);
-
- /**
- * The pattern for parameter length in printf specifier
- */
- public final static Pattern lengthPattern = Pattern.compile(LENGTH_PATTERN);
-
- /**
- * Hidden constructor
- */
- private SourceUtils() {
- }
-
- /**
- * Creates a header guard
- *
- * @param fileName
- * the name of the file
- * @return the header guard
- */
- public static String createHeaderGuard(String fileName) {
- StringBuffer sb = new StringBuffer();
- String uname = fileName.replace(SourceConstants.PERIOD_CHAR,
- SourceConstants.UNDERSCORE_CHAR).toUpperCase();
- sb.append(SourceConstants.IFNDEF);
- sb.append(SourceConstants.SPACE);
- sb.append(SourceConstants.DOUBLE_UNDERSCORE);
- sb.append(uname);
- sb.append(SourceConstants.DOUBLE_UNDERSCORE);
- sb.append(SourceConstants.LINE_FEED);
- sb.append(SourceConstants.DEFINE);
- sb.append(SourceConstants.SPACE);
- sb.append(SourceConstants.DOUBLE_UNDERSCORE);
- sb.append(uname);
- sb.append(SourceConstants.DOUBLE_UNDERSCORE);
- return sb.toString();
- }
-
- /**
- * Checks the validity of name
- *
- * @param name
- * the name
- * @return true if valid
- */
- public static boolean isValidName(String name) {
- boolean retval;
- if (name != null && name.length() > 0) {
- retval = true;
- if (!isValidNameStartChar(name.charAt(0))) {
- retval = false;
- } else {
- for (int i = 1; i < name.length() && retval; i++) {
- retval = isValidNameChar(name.charAt(i));
- }
- }
- } else {
- retval = false;
- }
- return retval;
- }
-
- /**
- * Checks the validity of parameter name
- *
- * @param name
- * the name
- * @return true if valid
- */
- public static boolean isValidParameterName(String name) {
- boolean retval;
- if (name != null && name.length() > 0) {
- retval = true;
- if (!isValidNameStartChar(name.charAt(0))) {
- retval = false;
- } else {
- for (int i = 1; i < name.length() && retval; i++) {
-
- // Check validity of the character
- char c = name.charAt(i);
- retval = (isValidNameChar(c) || isValidSpecialChar(c));
- }
- }
- } else {
- retval = false;
- }
- return retval;
- }
-
- /**
- * Checks special character validity
- *
- * @param c
- * character
- * @return true if valid
- */
- private static boolean isValidSpecialChar(char c) {
- boolean retval = false;
- // Check if the character is allowed
- if (c == '.' || c == '-' || c == '>' || c == '(' || c == ')'
- || c == '[' || c == ']' || c == ' ' || c == '&' || c == '*') {
- retval = true;
- }
- return retval;
- }
-
- /**
- * Checks start-of-name character validity
- *
- * @param c
- * character
- * @return true if valid
- */
- private static boolean isValidNameStartChar(char c) {
- // Ascii characters and underscore are allowed
- return (c >= 0x41 && c <= 0x5A) || (c >= 0x61 && c <= 0x7A) // CodForChk_Dis_Magic
- || c == 0x5F; // CodForChk_Dis_Magic
- }
-
- /**
- * Checks name character validity
- *
- * @param c
- * character
- * @return true if valid
- */
- private static boolean isValidNameChar(char c) {
- // Numbers are allowed in addition to start characters
- return isValidNameStartChar(c) || (c >= 0x30 && c <= 0x39); // CodForChk_Dis_Magic
- }
-
- /**
- * Maps a Symbian type to one of the TraceParameter types
- *
- * @param parsedType
- * the type parsed from source
- * @return the parameter type
- */
- public static TypeMapping mapSymbianTypeToParameterType(
- ParsedType parsedType) {
- String type = null;
- // The type map contains Symbian types
- for (int i = 0; i < SymbianConstants.PARAMETER_TYPE_MAP.length
- && type == null; i++) {
- if (parsedType
- .typeEquals(SymbianConstants.PARAMETER_TYPE_MAP[i][0])) {
- type = SymbianConstants.PARAMETER_TYPE_MAP[i][1];
- }
- }
- if (type != null) {
- if (parsedType.hasQualifier(SourceConstants.UNSIGNED)) {
- type = convertToUnsigned(type);
- }
- }
- TypeMapping retval = new TypeMapping(type);
- if (type != null) {
- // Value or a reference can be added to source as is
- // Points needs to be cast to HEX32
- if (parsedType.isPointer()) {
- retval.type = TraceParameter.HEX32;
- retval.needsCasting = true;
- } else {
- // TUint32 needs to be cast to TUint and TInt32 to TInt.
- // Otherwise there will be some problems with extension
- // headers
- if (parsedType.typeEquals(SymbianConstants.TUINT32)
- || parsedType.typeEquals(SymbianConstants.TINT32)) {
- retval.needsCasting = true;
- }
- }
- } else if (parsedType.isPointer()) {
- // Unrecognized pointer types are cast to Hex32
- retval.type = TraceParameter.HEX32;
- retval.needsCasting = true;
- } else {
- // Unrecognized value types are passed as pointer and cast to Hex32
- retval.type = TraceParameter.HEX32;
- retval.valueToPointer = true;
- retval.needsCasting = true;
- }
- return retval;
- }
-
- /**
- * Maps the type of a parameter to a Symbian type
- *
- * @param parameter
- * the parameter
- * @return the parameter type as string
- */
- public static String mapParameterTypeToSymbianType(TraceParameter parameter) {
- String retval;
- ArrayParameterRule rule = parameter
- .getExtension(ArrayParameterRule.class);
- String type = parameter.getType();
- TraceConstantTable table = parameter.getModel()
- .findConstantTableByName(type);
- if (table != null) {
- type = table.getType();
- }
- if (rule != null) {
- retval = mapArrayTypeToSymbianType(type);
- } else {
- retval = mapBasicTypeToSymbianType(type);
- }
- return retval;
- }
-
- /**
- * Maps a basic parameter type to Symbian type
- *
- * @param type
- * the parameter type
- * @return the Symbian type
- */
- public static String mapBasicTypeToSymbianType(String type) {
- String retval;
- // Unsigned and hex both use TUint types
- // Signed uses TInt types
- if (type.equals(TraceParameter.POINTER)) {
- retval = SymbianConstants.CONST_TANY_PTR;
- } else if (type.equals(TraceParameter.SDEC32)) {
- retval = SymbianConstants.TINT;
- } else if (type.equals(TraceParameter.UDEC32)
- || type.equals(TraceParameter.OCT32)
- || type.equals(TraceParameter.HEX32)) {
- retval = SymbianConstants.TUINT;
- } else if (type.equals(TraceParameter.SDEC16)) {
- retval = SymbianConstants.TINT16;
- } else if (type.equals(TraceParameter.UDEC16)
- || type.equals(TraceParameter.OCT16)
- || type.equals(TraceParameter.HEX16)) {
- retval = SymbianConstants.TUINT16;
- } else if (type.equals(TraceParameter.SDEC8)) {
- retval = SymbianConstants.TINT8;
- } else if (type.equals(TraceParameter.UDEC8)
- || type.equals(TraceParameter.OCT8)
- || type.equals(TraceParameter.HEX8)) {
- retval = SymbianConstants.TUINT8;
- } else if (type.equals(TraceParameter.SDEC64)
- || type.equals(TraceParameter.TIME)) {
- retval = SymbianConstants.TINT64;
- } else if (type.equals(TraceParameter.UDEC64)
- || type.equals(TraceParameter.OCT64)
- || type.equals(TraceParameter.HEX64)) {
- retval = SymbianConstants.TUINT64;
- } else if (type.equals(TraceParameter.ASCII)) {
- retval = SymbianConstants.CONST_TDESC8_REF;
- } else if (type.equals(TraceParameter.UNICODE)) {
- retval = SymbianConstants.CONST_TDESC16_REF;
- } else if (type.equals(TraceParameter.FLOAT_EXP)
- || type.equals(TraceParameter.FLOAT_FIX)
- || type.equals(TraceParameter.FLOAT_OPT)) {
- retval = SymbianConstants.TREAL;
- } else {
- retval = SymbianConstants.TANY_PTR;
- }
- return retval;
- }
-
- /**
- * Maps an array parameter type to Symbian type
- *
- * @param type
- * the parameter type
- * @return the Symbian type
- */
- public static String mapArrayTypeToSymbianType(String type) {
- String basic = mapBasicTypeToSymbianType(type);
- String retval = SourceConstants.OST_ARRAY_TYPE_PREFIX + basic
- + SourceConstants.OST_ARRAY_TYPE_POSTFIX;
- return retval;
- }
-
- /**
- * Maps a format specifier into parameter type
- *
- * @param formatSpecifier
- * the format specifier
- * @return the parameter type or null if not recognized. If the type is one
- * of the supported TraceParameter types, the string contains the
- * integer value of the type
- * @throws TraceCompilerException
- * if format specifier is not valid
- */
- public static FormatMapping mapFormatToParameterType(String formatSpecifier)
- throws TraceCompilerException {
- String type;
- boolean array = false;
- boolean basic = false;
- boolean extended = false;
- int len = formatSpecifier.length();
- // Extension format is checked first: %{x}
- if (len > 3 && formatSpecifier.charAt(1) == '{' // CodForChk_Dis_Magic
- && formatSpecifier.charAt(len - 1) == '}') {
- // Extension format can be an array: %{x[]}
- // In that case it could also be a basic type
- if (len > 3 + ARRAY_TAG.length() // CodForChk_Dis_Magic
- && formatSpecifier.charAt(len - 3) == '[' // CodForChk_Dis_Magic
- && formatSpecifier.charAt(len - 2) == ']') { // CodForChk_Dis_Magic
- type = formatSpecifier.substring(2, len - 1 // CodForChk_Dis_Magic
- - ARRAY_TAG.length());
- array = true;
- if (isStringType(type)) {
- StringErrorParameters param = new StringErrorParameters();
- param.string = type;
- throw new TraceCompilerException(
- TraceCompilerErrorCode.PARAMETER_FORMAT_NOT_SUPPORTED_IN_ARRAY,
- param, null);
- }
- } else {
- type = formatSpecifier.substring(2, len - 1); // CodForChk_Dis_Magic
- }
- extended = !isBasicType(type);
- } else {
- basic = true;
- type = formatSpecifier;
- }
-
- if (basic) {
- type = mapBasicFormatToType(formatSpecifier);
- }
- if (type == null) {
- StringErrorParameters params = new StringErrorParameters();
- params.string = formatSpecifier;
- throw new TraceCompilerException(
- TraceCompilerErrorCode.PARAMETER_FORMAT_NOT_SUPPORTED,
- params, null);
- }
- FormatMapping retval = new FormatMapping(type);
- retval.isArray = array;
- if (extended) {
- // In case of extended types, a constant table can still be
- // represented with normal trace macros.
- TraceConstantTable table = TraceCompilerEngineGlobals.getTraceModel()
- .findConstantTableByName(retval.type);
- if (table != null) {
- if (!array && isSimpleType(table.getType())) {
- retval.isSimple = true;
- }
- } else {
- // Extended type must be found from the property file
- StringErrorParameters params = new StringErrorParameters();
- params.string = formatSpecifier;
- throw new TraceCompilerException(
- TraceCompilerErrorCode.PARAMETER_FORMAT_NOT_SUPPORTED,
- params, null);
- }
- } else if (!retval.isArray) {
- retval.isSimple = isSimpleType(type);
- }
-
- return retval;
- }
-
- /**
- * Maps basic format specifies to parameter type
- *
- * @param formatSpecifier
- * the format specifies
- * @return the type
- * @throws TraceCompilerException
- * if mapping cannot be done
- */
- private static String mapBasicFormatToType(String formatSpecifier)
- throws TraceCompilerException { // CodForChk_Dis_ComplexFunc
- String type;
- int paramLength = SourceUtils
- .mapFormatToParameterLength(formatSpecifier);
- char formatChar = formatSpecifier.charAt(formatSpecifier.length() - 1);
- switch (formatChar) {
- case 'd':
- type = SourceUtils.mapSignedToParameterType(paramLength);
- break;
- case 'x':
- case 'X':
- type = SourceUtils.mapHexToParameterType(paramLength);
- break;
- case 'u':
- type = SourceUtils.mapUnsignedToParameterType(paramLength);
- break;
- case 'o':
- type = SourceUtils.mapOctalToParameterType(paramLength);
- break;
- case 's':
- type = TraceParameter.ASCII;
- break;
- case 'S': // Symbian extension
- type = TraceParameter.UNICODE;
- break;
- case 'c':
- type = TraceParameter.SDEC8;
- break;
- case 'p':
- type = TraceParameter.POINTER;
- break;
- case 'f':
- case 'F':
- type = TraceParameter.FLOAT_FIX;
- break;
- case 'e':
- case 'E':
- type = TraceParameter.FLOAT_EXP;
- break;
- case 'g':
- case 'G':
- type = TraceParameter.FLOAT_OPT;
- break;
- default:
- type = null;
- }
-
- return type;
- }
-
- /**
- * Maps a parameter type to format string
- *
- * @param parameter
- * the parameter
- * @return the format string
- */
- public static String mapParameterTypeToFormat(TraceParameter parameter) {
- String tag;
- if (parameter.getExtension(ArrayParameterRule.class) != null) {
- tag = mapArrayTypeToFormat(parameter.getType());
- } else {
- tag = mapNormalTypeToFormat(parameter.getType());
- }
- return tag;
- }
-
- /**
- * Maps an array type to basic type
- *
- * @param arrayType
- * the array type
- * @return the basic type or null if original type is not array type
- */
- public static String mapArrayTypeToBasicType(String arrayType) {
- String retval;
- if (arrayType.endsWith(ARRAY_TAG)) {
- retval = arrayType.substring(0, arrayType.length()
- - ARRAY_TAG.length());
- } else {
- retval = null;
- }
- return retval;
- }
-
- /**
- * Parses a numeric value from source
- *
- * @param number
- * the number as string
- * @return the value
- */
- public static int parseNumberFromSource(String number) {
- int ret;
- String low = number.toLowerCase();
- int radix;
- if (low.startsWith(SourceConstants.HEX_PREFIX)) {
- radix = 16; // CodForChk_Dis_Magic
- low = low.substring(SourceConstants.HEX_PREFIX.length());
- } else if (low.startsWith(SourceConstants.OCTAL_PREFIX)
- && low.length() > SourceConstants.OCTAL_PREFIX.length()
- && Character.isDigit(low.charAt(SourceConstants.OCTAL_PREFIX
- .length()))) {
- radix = 8; // CodForChk_Dis_Magic
- low = low.substring(SourceConstants.OCTAL_PREFIX.length());
- } else {
- radix = 10; // CodForChk_Dis_Magic
- }
- if (low.endsWith(SourceConstants.I64_POSTFIX)) {
- low = low.substring(0, low.length()
- - SourceConstants.I64_POSTFIX.length());
- }
- if (low.length() > 0) {
- // Removes U / L characters from the end of value
- int index = low.length() - 1;
- boolean complete = false;
- do {
- char c = low.charAt(index);
- if (c == 'u' || c == 'l') {
- index--;
- } else {
- complete = true;
- }
- } while (!complete && index >= 0);
- if (index < low.length() - 1 && index > 0) {
- low = low.substring(0, index + 1);
- }
- ret = Integer.parseInt(low, radix);
- } else {
- ret = 0;
- }
- return ret;
- }
-
- /**
- * Calculates the size of parameter
- *
- * @param parameter
- * the parameter
- * @return the parameter size or 0 if the size is not known at compile time
- */
- public static int mapParameterTypeToSize(TraceParameter parameter) {
- int retval;
- ArrayParameterRule rule = parameter
- .getExtension(ArrayParameterRule.class);
- if (rule != null) {
- // Array parameters are dynamic
- retval = 0;
- } else {
- String type = parameter.getType();
- TraceConstantTable table = parameter.getModel()
- .findConstantTableByName(type);
- if (table != null) {
- type = table.getType();
- }
- retval = mapParameterTypeToSize(type);
- }
- return retval;
- }
-
- /**
- * Calculates the size of parameter type
- *
- * @param type
- * the parameter type
- * @return the parameter size or 0 if size is not known at compile time
- */
- public static int mapParameterTypeToSize(String type) {
- int retval;
- if (type.equals(TraceParameter.HEX32)
- || type.equals(TraceParameter.UDEC32)
- || type.equals(TraceParameter.SDEC32)
- || type.equals(TraceParameter.OCT32)
- || type.equals(TraceParameter.POINTER)) {
- retval = 4; // CodForChk_Dis_Magic
- } else if (type.equals(TraceParameter.HEX16)
- || type.equals(TraceParameter.UDEC16)
- || type.equals(TraceParameter.SDEC16)
- || type.equals(TraceParameter.OCT16)) {
- retval = 2; // CodForChk_Dis_Magic
- } else if (type.equals(TraceParameter.HEX8)
- || type.equals(TraceParameter.UDEC8)
- || type.equals(TraceParameter.SDEC8)
- || type.equals(TraceParameter.OCT8)) {
- retval = 1;
- } else if (type.equals(TraceParameter.HEX64)
- || type.equals(TraceParameter.UDEC64)
- || type.equals(TraceParameter.SDEC64)
- || type.equals(TraceParameter.OCT64)
- || type.equals(TraceParameter.FLOAT_EXP)
- || type.equals(TraceParameter.FLOAT_FIX)
- || type.equals(TraceParameter.FLOAT_OPT)) {
- retval = 8; // CodForChk_Dis_Magic
- } else {
- retval = 0;
- }
- return retval;
- }
-
- /**
- * Removes printf formatting from trace text
- *
- * @param text
- * the text to be converted
- * @return the new text
- */
- public static String removePrintfFormatting(String text) {
- Matcher matcher = traceTextPattern.matcher(text);
- return matcher.replaceAll(""); //$NON-NLS-1$
- }
-
- /**
- * Converts the given type to unsigned type
- *
- * @param type
- * the type
- * @return unsigned type
- */
- private static String convertToUnsigned(String type) {
- if (type.equals(TraceParameter.SDEC32)) {
- type = TraceParameter.UDEC32;
- } else if (type.equals(TraceParameter.SDEC16)) {
- type = TraceParameter.UDEC16;
- } else if (type.equals(TraceParameter.SDEC8)) {
- type = TraceParameter.UDEC8;
- } else if (type.equals(TraceParameter.SDEC64)) {
- type = TraceParameter.UDEC64;
- }
- return type;
- }
-
- /**
- * Maps a normal parameter type for format character
- *
- * @param type
- * the parameter type
- * @return the format character
- */
- public static String mapNormalTypeToFormat(String type) { // CodForChk_Dis_ComplexFunc
- String tag;
- if (type.equals(TraceParameter.SDEC32)) {
- tag = "%d"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.POINTER)) {
- tag = "%p"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.HEX32)) {
- tag = "%x"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.UDEC32)) {
- tag = "%u"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.OCT32)) {
- tag = "%o"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.SDEC16)) {
- tag = "%hd"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.HEX16)) {
- tag = "%hx"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.UDEC16)) {
- tag = "%hu"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.OCT16)) {
- tag = "%ho"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.SDEC8)) {
- tag = "%hhd"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.HEX8)) {
- tag = "%hhx"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.UDEC8)) {
- tag = "%hhu"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.OCT8)) {
- tag = "%hho"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.SDEC64)) {
- tag = "%Ld"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.HEX64)) {
- tag = "%Lx"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.UDEC64)) {
- tag = "%Lu"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.OCT64)) {
- tag = "%Lo"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.ASCII)) {
- tag = "%s"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.UNICODE)) {
- tag = "%S"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.FLOAT_FIX)) {
- tag = "%f"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.FLOAT_EXP)) {
- tag = "%e"; //$NON-NLS-1$
- } else if (type.equals(TraceParameter.FLOAT_OPT)) {
- tag = "%g"; //$NON-NLS-1$
- } else {
- tag = "%{" //$NON-NLS-1$
- + type + "}"; //$NON-NLS-1$
- }
- return tag;
- }
-
- /**
- * Maps an array parameter type to format string
- *
- * @param type
- * the parameter type
- * @return the format string
- */
- public static String mapArrayTypeToFormat(String type) {
- String tag = "%{" //$NON-NLS-1$
- + type + "[]}"; //$NON-NLS-1$
- return tag;
- }
-
- /**
- * Maps format specifier to parameter length
- *
- * @param formatSpecifier
- * the specifier
- * @return the length
- * @throws TraceCompilerException
- * if length is not valid
- */
- public static int mapFormatToParameterLength(String formatSpecifier)
- throws TraceCompilerException {
- Matcher matcher = SourceUtils.lengthPattern.matcher(formatSpecifier);
- int paramLength = 0;
- if (matcher.find()) {
- String length = matcher.group();
-
- if (length.length() == 2) { // CodForChk_Dis_Magic
- if (length.charAt(0) == 'h' && length.charAt(1) == 'h') {
- paramLength = SourceConstants.BYTE_SIZE;
- } else if (length.charAt(0) == 'l' && length.charAt(1) == 'l') {
- paramLength = SourceConstants.LONG_SIZE;
- } else {
- StringErrorParameters params = new StringErrorParameters();
- params.string = formatSpecifier;
- throw new TraceCompilerException(
- TraceCompilerErrorCode.PARAMETER_FORMAT_NOT_SUPPORTED,
- params, null);
- }
- } else if (length.length() == 1) {
- switch (length.charAt(0)) {
- case 'h':
- paramLength = SourceConstants.SHORT_SIZE;
- break;
- case 'l':
- paramLength = SourceConstants.INT_SIZE;
- break;
- case 'L':
- paramLength = SourceConstants.LONG_SIZE;
- break;
- default:
- StringErrorParameters params = new StringErrorParameters();
- params.string = formatSpecifier;
- throw new TraceCompilerException(
- TraceCompilerErrorCode.PARAMETER_FORMAT_NOT_SUPPORTED,
- params, null);
- }
- } else {
- throw new TraceCompilerException(
- TraceCompilerErrorCode.INVALID_TRACE_TEXT_FORMAT, null,
- formatSpecifier);
- }
- }
-
- return paramLength;
- }
-
- /**
- * Maps signed parameter length to type
- *
- * @param paramLength
- * the length
- * @return the type
- */
- private static String mapSignedToParameterType(int paramLength) {
- String retval;
- if (paramLength == SourceConstants.BYTE_SIZE) {
- retval = TraceParameter.SDEC8;
- } else if (paramLength == SourceConstants.SHORT_SIZE) {
- retval = TraceParameter.SDEC16;
- } else if (paramLength == SourceConstants.LONG_SIZE) {
- retval = TraceParameter.SDEC64;
- } else {
- retval = TraceParameter.SDEC32;
- }
- return retval;
- }
-
- /**
- * Maps unsigned parameter length to type
- *
- * @param paramLength
- * the length
- * @return the type
- */
- public static String mapUnsignedToParameterType(int paramLength) {
- String retval;
- if (paramLength == SourceConstants.BYTE_SIZE) {
- retval = TraceParameter.UDEC8;
- } else if (paramLength == SourceConstants.SHORT_SIZE) {
- retval = TraceParameter.UDEC16;
- } else if (paramLength == SourceConstants.LONG_SIZE) {
- retval = TraceParameter.UDEC64;
- } else {
- retval = TraceParameter.UDEC32;
- }
- return retval;
- }
-
- /**
- * Maps hex parameter length to type
- *
- * @param paramLength
- * the length
- * @return the type
- */
- public static String mapHexToParameterType(int paramLength) {
- String retval;
- if (paramLength == SourceConstants.BYTE_SIZE) {
- retval = TraceParameter.HEX8;
- } else if (paramLength == SourceConstants.SHORT_SIZE) {
- retval = TraceParameter.HEX16;
- } else if (paramLength == SourceConstants.LONG_SIZE) {
- retval = TraceParameter.HEX64;
- } else {
- retval = TraceParameter.HEX32;
- }
- return retval;
- }
-
- /**
- * Maps octal parameter length to type
- *
- * @param paramLength
- * the length
- * @return the type
- */
- public static String mapOctalToParameterType(int paramLength) {
- String retval;
- if (paramLength == SourceConstants.BYTE_SIZE) {
- retval = TraceParameter.OCT8;
- } else if (paramLength == SourceConstants.SHORT_SIZE) {
- retval = TraceParameter.OCT16;
- } else if (paramLength == SourceConstants.LONG_SIZE) {
- retval = TraceParameter.OCT64;
- } else {
- retval = TraceParameter.OCT32;
- }
-
- return retval;
- }
-
- /**
- * Checks if the parameter can be represented with default trace macros
- *
- * @param parameter
- * the parameter
- * @return true if parameter can be represented with default trace macros
- */
- public static boolean isSimpleType(TraceParameter parameter) {
- boolean retval;
- if (parameter.getExtension(ArrayParameterRule.class) != null) {
- // Arrays are always complex types
- retval = false;
- } else {
- String type = parameter.getType();
- TraceConstantTable table = parameter.getModel()
- .findConstantTableByName(type);
- if (table != null) {
- type = table.getType();
- }
- retval = isSimpleType(type);
- }
- return retval;
- }
-
- /**
- * Simple type is 32-bit integer
- *
- * @param type
- * the type
- * @return true if simple, false if not
- */
- private static boolean isSimpleType(String type) {
- return type.equals(TraceParameter.SDEC32)
- || type.equals(TraceParameter.UDEC32)
- || type.equals(TraceParameter.OCT32)
- || type.equals(TraceParameter.HEX32);
- }
-
- /**
- * String type is either ascii or unicode
- *
- * @param type
- * the type
- * @return true if string, false if not
- */
- private static boolean isStringType(String type) {
- return type.equals(TraceParameter.ASCII)
- || type.equals(TraceParameter.UNICODE);
- }
-
- /**
- * Basic type is any of the built-in TraceParameter types
- *
- * @param type
- * the type
- * @return true if basic, false if not
- */
- private static boolean isBasicType(String type) {
- return isSimpleType(type) || type.equals(TraceParameter.SDEC8)
- || type.equals(TraceParameter.SDEC16)
- || type.equals(TraceParameter.UDEC8)
- || type.equals(TraceParameter.UDEC16)
- || type.equals(TraceParameter.OCT16)
- || type.equals(TraceParameter.HEX8)
- || type.equals(TraceParameter.HEX16)
- || type.equals(TraceParameter.SDEC64)
- || type.equals(TraceParameter.UDEC64)
- || type.equals(TraceParameter.OCT64)
- || type.equals(TraceParameter.HEX64)
- || type.equals(TraceParameter.ASCII)
- || type.equals(TraceParameter.UNICODE)
- || type.equals(TraceParameter.FLOAT_EXP)
- || type.equals(TraceParameter.FLOAT_FIX)
- || type.equals(TraceParameter.FLOAT_OPT)
- || type.equals(TraceParameter.POINTER);
- }
-
- /**
- * Checks if parameter size is dynamic
- *
- * @param parameter
- * the parameter to be checked
- * @return true if dynamic size
- */
- public static boolean isParameterSizeDynamic(TraceParameter parameter) {
- String type = parameter.getType();
- ArrayParameterRule rule = parameter
- .getExtension(ArrayParameterRule.class);
- return rule != null || type.equals(TraceParameter.ASCII)
- || type.equals(TraceParameter.UNICODE);
- }
-
- /**
- * Checks if alignment is needed
- *
- * @param type
- * the parameter type
- * @return true if alignment is needed
- */
- public static boolean isParameterAlignementNeeded(String type) {
- int size = SourceUtils.mapParameterTypeToSize(type);
- boolean retval = false;
- if (size == 1 || size == 2) { // CodForChk_Dis_Magic
- // 8 and 16-bit parameters need alignment
- retval = true;
- } else if (isStringType(type)) {
- retval = true;
- }
- return retval;
- }
-
-}