/*

* 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:

	 * 

	 * <strong> 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.</strong>

	 * 

	 * 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:

	 * 

	 * <strong> Flags can be zero or more (in any order) of:

	 * <ul>

	 * <li>'+' : 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.

	 * <li>'-' : Causes printf to left-align the output of this placeholder (the

	 * default is to right-align the output).

	 * <li>'#' : 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.

	 * <li>' ' : 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

	 * <li>'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"

	 * </ul>

	 * </strong>

	 */

	private final static String FLAGS_PATTERN = "([-+# 0])"; //$NON-NLS-1$

	/**

	 * Optional width pattern. Quoted from Wikipedia:

	 * 

	 * <strong>Width can be omitted or be any of:

	 * <ul>

	 * <li>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.

	 * <li>'*' : 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.</strong>

	 * </ul>

	 * </strong>

	 * 

	 * '*' 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: <strong>

	 * <ul>

	 * <li>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.

	 * <li>'*' : 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.

	 * </ul>

	 * </strong> 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: <strong>

	 * <ul>

	 * <li>'hh' : For integer types, causes printf to expect an int sized

	 * integer argument which was promoted from a char.

	 * <li>'h' : For integer types, causes printf to expect a int sized integer

	 * argument which was promoted from a short.

	 * <li>'l' : (ell) For integer types, causes printf to expect a long sized

	 * integer argument.

	 * <li>'ll' : (ell ell) For integer types, causes printf to expect a long

	 * long sized integer argument.

	 * <li>'L' : For floating point types, causes printf to expect a long double

	 * argument.

	 * <li>'z' : For integer types, causes printf to expect a size_t sized

	 * integer argument.

	 * <li>'j' : For integer types, causes printf to expect a intmax_t sized

	 * integer argument.

	 * <li>'t' : For integer types, causes printf to expect a ptrdiff_t sized

	 * integer argument.

	 * </ul>

	 * </strong>

	 */

	private final static String LENGTH_PATTERN = "([lh]?[hHlLZjt])"; //$NON-NLS-1$

	/**

	 * Type pattern. Quoted from Wikipedia:

	 * 

	 * <strong> type can be any of:

	 * <ul>

	 * <li>'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.

	 * <li>'u' : Print decimal unsigned int.

	 * <li>'f', 'F' : Print a double in normal (fixed-point) notation.

	 * <li>'e', 'E' : Print a double value in standard form ([-]d.ddd

	 * e[+/-]ddd).

	 * <li>'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.

	 * <li>'x', 'X' : Print an unsigned int as a hexadecimal number. 'x' uses

	 * lower-case letters and 'X' uses upper-case.

	 * <li>'o' : Print an unsigned int in octal.

	 * <li>'s' : Print a character string.

	 * <li>'c' : Print a char (character).

	 * <li>'p' : Print a void * (pointer to void) in an implementation-defined

	 * format.

	 * <li>'n' : Write number of characters successfully written so far into an

	 * integer pointer parameter.

	 * <li>'%' : Print a literal '%' character (this type doesn't accept any

	 * flags, width, precision or length).

	 * </ul>

	 * </strong>

	 * 

	 * 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)) {