Subversion Repositories HelenOS

/*

 * Copyright (c) 2001-2004 Jakub Jermar

 * Copyright (c) 2006 Josef Cejka

 * Copyright (c) 2009 Martin Decky

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 *

 * - Redistributions of source code must retain the above copyright

 *   notice, this list of conditions and the following disclaimer.

 * - Redistributions in binary form must reproduce the above copyright

 *   notice, this list of conditions and the following disclaimer in the

 *   documentation and/or other materials provided with the distribution.

 * - The name of the author may not be used to endorse or promote products

 *   derived from this software without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

/** @addtogroup generic

 * @{

 */

/**

 * @file

 * @brief Printing functions.

 */

#include <printf/printf_core.h>

#include <print.h>

#include <arch/arg.h>

#include <macros.h>

#include <string.h>

#include <arch.h>

/** show prefixes 0x or 0 */

#define __PRINTF_FLAG_PREFIX       0x00000001

/** signed / unsigned number */

#define __PRINTF_FLAG_SIGNED       0x00000002

/** print leading zeroes */

#define __PRINTF_FLAG_ZEROPADDED   0x00000004

/** align to left */

#define __PRINTF_FLAG_LEFTALIGNED  0x00000010

/** always show + sign */

#define __PRINTF_FLAG_SHOWPLUS     0x00000020

/** print space instead of plus */

#define __PRINTF_FLAG_SPACESIGN    0x00000040

/** show big characters */

#define __PRINTF_FLAG_BIGCHARS     0x00000080

/** number has - sign */

#define __PRINTF_FLAG_NEGATIVE     0x00000100

/**

 * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0

 * to terminate string... (last one is only for better testing end of buffer by

 * zero-filling subroutine)

 */

#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)

/** Enumeration of possible arguments types.

 */

typedef enum {

	PrintfQualifierByte = 0,

	PrintfQualifierShort,

	PrintfQualifierInt,

	PrintfQualifierLong,

	PrintfQualifierLongLong,

	PrintfQualifierPointer

} qualifier_t;

static char nullstr[] = "(NULL)";

static char digits_small[] = "0123456789abcdef";

static char digits_big[] = "0123456789ABCDEF";

static char invalch = U_SPECIAL;

/** Print one or more characters without adding newline.

 *

 * @param buf  Buffer holding characters with size of

 *             at least size bytes. NULL is not allowed!

 * @param size Size of the buffer in bytes.

 * @param ps   Output method and its data.

 *

 * @return Number of characters printed.

 *

 */

static int printf_putnchars(const char *buf, size_t size,

    printf_spec_t *ps)

{

	return ps->str_write((void *) buf, size, ps->data);

}

/** Print one or more wide characters without adding newline.

 *

 * @param buf  Buffer holding wide characters with size of

 *             at least size bytes. NULL is not allowed!

 * @param size Size of the buffer in bytes.

 * @param ps   Output method and its data.

 *

 * @return Number of wide characters printed.

 *

 */

static int printf_wputnchars(const wchar_t *buf, size_t size,

    printf_spec_t *ps)

{

	return ps->wstr_write((void *) buf, size, ps->data);

}

/** Print string without adding a newline.

 *

 * @param str String to print.

 * @param ps  Write function specification and support data.

 *

 * @return Number of characters printed.

 *

 */

static int printf_putstr(const char *str, printf_spec_t *ps)

{

	if (str == NULL)

		return printf_putnchars(nullstr, str_size(nullstr), ps);

	return ps->str_write((void *) str, str_size(str), ps->data);

}

/** Print one ASCII character.

 *

 * @param c  ASCII character to be printed.

 * @param ps Output method.

 *

 * @return Number of characters printed.

 *

 */

static int printf_putchar(const char ch, printf_spec_t *ps)

{

	if (!ascii_check(ch))

		return ps->str_write((void *) &invalch, 1, ps->data);

	return ps->str_write(&ch, 1, ps->data);

}

/** Print one wide character.

 *

 * @param c  Wide character to be printed.

 * @param ps Output method.

 *

 * @return Number of characters printed.

 *

 */

static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)

{

	if (!chr_check(ch))

		return ps->str_write((void *) &invalch, 1, ps->data);

	return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);

}

/** Print one formatted ASCII character.

 *

 * @param ch    Character to print.

 * @param width Width modifier.

 * @param flags Flags that change the way the character is printed.

 *

 * @return Number of characters printed, negative value on failure.

 *

 */

static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)

{

	size_t counter = 0;

	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {

		while (--width > 0) {

			/*

			 * One space is consumed by the character itself, hence

			 * the predecrement.

			 */

			if (printf_putchar(' ', ps) > 0)

				counter++;

		}

	}

	if (printf_putchar(ch, ps) > 0)

		counter++;

	while (--width > 0) {

		/*

		 * One space is consumed by the character itself, hence

		 * the predecrement.

		 */

		if (printf_putchar(' ', ps) > 0)

			counter++;

	}

	return (int) (counter + 1);

}

/** Print one formatted wide character.

 *

 * @param ch    Character to print.

 * @param width Width modifier.

 * @param flags Flags that change the way the character is printed.

 *

 * @return Number of characters printed, negative value on failure.

 *

 */

static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)

{

	size_t counter = 0;

	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {

		while (--width > 0) {

			/*

			 * One space is consumed by the character itself, hence

			 * the predecrement.

			 */

			if (printf_putchar(' ', ps) > 0)

				counter++;

		}

	}

	if (printf_putwchar(ch, ps) > 0)

		counter++;

	while (--width > 0) {

		/*

		 * One space is consumed by the character itself, hence

		 * the predecrement.

		 */

		if (printf_putchar(' ', ps) > 0)

			counter++;

	}

	return (int) (counter + 1);

}

/** Print string.

 *

 * @param str       String to be printed.

 * @param width     Width modifier.

 * @param precision Precision modifier.

 * @param flags     Flags that modify the way the string is printed.

 *

 * @return Number of characters printed, negative value on failure.

 */

static int print_str(char *str, int width, unsigned int precision,

    uint32_t flags, printf_spec_t *ps)

{

	if (str == NULL)

		return printf_putstr(nullstr, ps);

	/* Print leading spaces. */

	size_t strw = str_length(str);

	if (precision == 0)

		precision = strw;

	/* Left padding */

	size_t counter = 0;

	width -= precision;

	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {

		while (width-- > 0) {

			if (printf_putchar(' ', ps) == 1)

				counter++;

		}

	}

	/* Part of @a str fitting into the alloted space. */

	int retval;

	size_t size = str_lsize(str, precision);

	if ((retval = printf_putnchars(str, size, ps)) < 0)

		return -counter;

	counter += retval;

	/* Right padding */

	while (width-- > 0) {

		if (printf_putchar(' ', ps) == 1)

			counter++;

	}

	return ((int) counter);

}

/** Print wide string.

 *

 * @param str       Wide string to be printed.

 * @param width     Width modifier.

 * @param precision Precision modifier.

 * @param flags     Flags that modify the way the string is printed.

 *

 * @return Number of wide characters printed, negative value on failure.

 */

static int print_wstr(wchar_t *str, int width, unsigned int precision,

    uint32_t flags, printf_spec_t *ps)

{

	if (str == NULL)

		return printf_putstr(nullstr, ps);

	/* Print leading spaces. */

	size_t strw = wstr_length(str);

	if (precision == 0)

		precision = strw;

	/* Left padding */

	size_t counter = 0;

	width -= precision;

	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {

		while (width-- > 0) {

			if (printf_putchar(' ', ps) == 1)

				counter++;

		}

	}

	/* Part of @a wstr fitting into the alloted space. */

	int retval;

	size_t size = wstr_lsize(str, precision);

	if ((retval = printf_wputnchars(str, size, ps)) < 0)

		return -counter;

	counter += retval;

	/* Right padding */

	while (width-- > 0) {

		if (printf_putchar(' ', ps) == 1)

			counter++;

	}

	return ((int) counter);

}

/** Print a number in a given base.

 *

 * Print significant digits of a number in given base.

 *

 * @param num       Number to print.

 * @param width     Width modifier.

 * @param precision Precision modifier.

 * @param base      Base to print the number in (must be between 2 and 16).

 * @param flags     Flags that modify the way the number is printed.

 *

 * @return Number of characters printed.

 *

 */

static int print_number(uint64_t num, int width, int precision, int base,

    uint32_t flags, printf_spec_t *ps)

{

	char *digits;

	if (flags & __PRINTF_FLAG_BIGCHARS)

		digits = digits_big;

	else

		digits = digits_small;

	char data[PRINT_NUMBER_BUFFER_SIZE];

	char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];

	/* Size of number with all prefixes and signs */

	int size = 0;

	/* Put zero at end of string */

	*ptr-- = 0;

	if (num == 0) {

		*ptr-- = '0';

		size++;

	} else {

		do {

			*ptr-- = digits[num % base];

			size++;

		} while (num /= base);

	}

	/* Size of plain number */

	int number_size = size;

	/*

	 * Collect the sum of all prefixes/signs/etc. to calculate padding and

	 * leading zeroes.

	 */

	if (flags & __PRINTF_FLAG_PREFIX) {

		switch(base) {

		case 2:

			/* Binary formating is not standard, but usefull */

			size += 2;

			break;

		case 8:

			size++;

			break;

		case 16:

			size += 2;

			break;

		}

	}

	char sgn = 0;

	if (flags & __PRINTF_FLAG_SIGNED) {

		if (flags & __PRINTF_FLAG_NEGATIVE) {

			sgn = '-';

			size++;

		} else if (flags & __PRINTF_FLAG_SHOWPLUS) {

			sgn = '+';

			size++;

		} else if (flags & __PRINTF_FLAG_SPACESIGN) {

			sgn = ' ';

			size++;

		}

	}

	if (flags & __PRINTF_FLAG_LEFTALIGNED)

		flags &= ~__PRINTF_FLAG_ZEROPADDED;

	/*

	 * If the number is left-aligned or precision is specified then

	 * padding with zeros is ignored.

	 */

	if (flags & __PRINTF_FLAG_ZEROPADDED) {

		if ((precision == 0) && (width > size))

			precision = width - size + number_size;

	}

	/* Print leading spaces */

	if (number_size > precision) {

		/* Print the whole number, not only a part */

		precision = number_size;

	}

	width -= precision + size - number_size;

	size_t counter = 0;

	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {

		while (width-- > 0) {

			if (printf_putchar(' ', ps) == 1)

				counter++;

		}

	}

	/* Print sign */

	if (sgn) {

		if (printf_putchar(sgn, ps) == 1)

			counter++;

	}

	/* Print prefix */

	if (flags & __PRINTF_FLAG_PREFIX) {

		switch(base) {

		case 2:

			/* Binary formating is not standard, but usefull */

			if (printf_putchar('0', ps) == 1)

				counter++;

			if (flags & __PRINTF_FLAG_BIGCHARS) {

				if (printf_putchar('B', ps) == 1)

					counter++;

			} else {

				if (printf_putchar('b', ps) == 1)

					counter++;

			}

			break;

		case 8:

			if (printf_putchar('o', ps) == 1)

				counter++;

			break;

		case 16:

			if (printf_putchar('0', ps) == 1)

				counter++;

			if (flags & __PRINTF_FLAG_BIGCHARS) {

				if (printf_putchar('X', ps) == 1)

					counter++;

			} else {

				if (printf_putchar('x', ps) == 1)

					counter++;

			}

			break;

		}

	}

	/* Print leading zeroes */

	precision -= number_size;

	while (precision-- > 0) {

		if (printf_putchar('0', ps) == 1)

			counter++;

	}

	/* Print the number itself */

	int retval;

	if ((retval = printf_putstr(++ptr, ps)) > 0)

		counter += retval;

	/* Print tailing spaces */

	while (width-- > 0) {

		if (printf_putchar(' ', ps) == 1)

			counter++;

	}

	return ((int) counter);

}

/** Print formatted string.

 *

 * Print string formatted according to the fmt parameter and variadic arguments.

 * Each formatting directive must have the following form:

 *

 *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION

 *

 * FLAGS:@n

 *  - "#" Force to print prefix. For \%o conversion, the prefix is 0, for

 *        \%x and \%X prefixes are 0x and 0X and for conversion \%b the

 *        prefix is 0b.

 *

 *  - "-" Align to left.

 *

 *  - "+" Print positive sign just as negative.

 *

 *  - " " If the printed number is positive and "+" flag is not set,

 *        print space in place of sign.

 *

 *  - "0" Print 0 as padding instead of spaces. Zeroes are placed between

 *        sign and the rest of the number. This flag is ignored if "-"

 *        flag is specified.

 *

 * WIDTH:@n

 *  - Specify the minimal width of a printed argument. If it is bigger,

 *    width is ignored. If width is specified with a "*" character instead of

 *    number, width is taken from parameter list. And integer parameter is

 *    expected before parameter for processed conversion specification. If

 *    this value is negative its absolute value is taken and the "-" flag is

 *    set.

 *

 * PRECISION:@n

 *  - Value precision. For numbers it specifies minimum valid numbers.

 *    Smaller numbers are printed with leading zeroes. Bigger numbers are not

 *    affected. Strings with more than precision characters are cut off. Just

 *    as with width, an "*" can be used used instead of a number. An integer

 *    value is then expected in parameters. When both width and precision are

 *    specified using "*", the first parameter is used for width and the

 *    second one for precision.

 *

 * TYPE:@n

 *  - "hh" Signed or unsigned char.@n

 *  - "h"  Signed or unsigned short.@n

 *  - ""   Signed or unsigned int (default value).@n

 *  - "l"  Signed or unsigned long int.@n

 *         If conversion is "c", the character is wchar_t (wide character).@n

 *         If conversion is "s", the string is wchar_t * (wide string).@n

 *  - "ll" Signed or unsigned long long int.@n

 *

 * CONVERSION:@n

 *  - % Print percentile character itself.

 *

 *  - c Print single character. The character is expected to be plain

 *      ASCII (e.g. only values 0 .. 127 are valid).@n

 *      If type is "l", then the character is expected to be wide character

 *      (e.g. values 0 .. 0x10ffff are valid).

 *

 *  - s Print zero terminated string. If a NULL value is passed as

 *      value, "(NULL)" is printed instead.@n

 *      If type is "l", then the string is expected to be wide string.

 *

 *  - P, p Print value of a pointer. Void * value is expected and it is

 *         printed in hexadecimal notation with prefix (as with \%#X / \%#x

 *         for 32-bit or \%#X / \%#x for 64-bit long pointers).

 *

 *  - b Print value as unsigned binary number. Prefix is not printed by

 *      default. (Nonstandard extension.)

 *

 *  - o Print value as unsigned octal number. Prefix is not printed by

 *      default.

 *

 *  - d, i Print signed decimal number. There is no difference between d

 *         and i conversion.

 *

 *  - u Print unsigned decimal number.

 *

 *  - X, x Print hexadecimal number with upper- or lower-case. Prefix is

 *         not printed by default.

 *

 * All other characters from fmt except the formatting directives are printed

 * verbatim.

 *

 * @param fmt Format NULL-terminated string.

 *

 * @return Number of characters printed, negative value on failure.

 *

 */

int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)

{

	size_t i;        /* Index of the currently processed character from fmt */

	size_t nxt = 0;  /* Index of the next character from fmt */

	size_t j = 0;    /* Index to the first not printed nonformating character */

	size_t counter = 0;   /* Number of characters printed */

	int retval;           /* Return values from nested functions */

	while (true) {

		i = nxt;

		wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

		if (uc == 0)

			break;

		/* Control character */

		if (uc == '%') {

			/* Print common characters if any processed */

			if (i > j) {

				if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {

					/* Error */

					counter = -counter;

					goto out;

				}

				counter += retval;

			}

			j = i;

			/* Parse modifiers */

			uint32_t flags = 0;

			bool end = false;

			do {

				i = nxt;

				uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

				switch (uc) {

				case '#':

					flags |= __PRINTF_FLAG_PREFIX;

					break;

				case '-':

					flags |= __PRINTF_FLAG_LEFTALIGNED;

					break;

				case '+':

					flags |= __PRINTF_FLAG_SHOWPLUS;

					break;

				case ' ':

					flags |= __PRINTF_FLAG_SPACESIGN;

					break;

				case '0':

					flags |= __PRINTF_FLAG_ZEROPADDED;

					break;

				default:

					end = true;

				};

			} while (!end);

			/* Width & '*' operator */

			int width = 0;

			if (isdigit(uc)) {

				while (true) {

					width *= 10;

					width += uc - '0';

					i = nxt;

					uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

					if (uc == 0)

						break;

					if (!isdigit(uc))

						break;

				}

			} else if (uc == '*') {

				/* Get width value from argument list */

				i = nxt;

				uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

				width = (int) va_arg(ap, int);

				if (width < 0) {

					/* Negative width sets '-' flag */

					width *= -1;

					flags |= __PRINTF_FLAG_LEFTALIGNED;

				}

			}

			/* Precision and '*' operator */

			int precision = 0;

			if (uc == '.') {

				i = nxt;

				uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

				if (isdigit(uc)) {

					while (true) {

						precision *= 10;

						precision += uc - '0';

						i = nxt;

						uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

						if (uc == 0)

							break;

						if (!isdigit(uc))

							break;

					}

				} else if (uc == '*') {

					/* Get precision value from the argument list */

					i = nxt;

					uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

					precision = (int) va_arg(ap, int);

					if (precision < 0) {

						/* Ignore negative precision */

						precision = 0;

					}

				}

			}

			qualifier_t qualifier;

			switch (uc) {

			/** @todo Unimplemented qualifiers:

			 *        t ptrdiff_t - ISO C 99

			 */

			case 'h':

				/* Char or short */

				qualifier = PrintfQualifierShort;

				i = nxt;

				uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

				if (uc == 'h') {

					i = nxt;

					uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

					qualifier = PrintfQualifierByte;

				}

				break;

			case 'l':

				/* Long or long long */

				qualifier = PrintfQualifierLong;

				i = nxt;

				uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

				if (uc == 'l') {

					i = nxt;

					uc = str_decode(fmt, &nxt, STR_NO_LIMIT);

					qualifier = PrintfQualifierLongLong;

				}

				break;

			default:

				/* Default type */

				qualifier = PrintfQualifierInt;

			}

			unsigned int base = 10;

			switch (uc) {

			/*

			 * String and character conversions.

			 */

			case 's':

				if (qualifier == PrintfQualifierLong)

					retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);

				else

					retval = print_str(va_arg(ap, char *), width, precision, flags, ps);

				if (retval < 0) {

					counter = -counter;

					goto out;

				}

				counter += retval;

				j = nxt;

				goto next_char;

			case 'c':

				if (qualifier == PrintfQualifierLong)

					retval = print_wchar(va_arg(ap, wchar_t), width, flags, ps);

				else

					retval = print_char(va_arg(ap, unsigned int), width, flags, ps);

				if (retval < 0) {

					counter = -counter;

					goto out;

				};

				counter += retval;

				j = nxt;

				goto next_char;

			/*

			 * Integer values

			 */

			case 'P':

				/* Pointer */

				flags |= __PRINTF_FLAG_BIGCHARS;

			case 'p':

				flags |= __PRINTF_FLAG_PREFIX;

				base = 16;

				qualifier = PrintfQualifierPointer;

				break;

			case 'b':

				base = 2;

				break;

			case 'o':

				base = 8;

				break;

			case 'd':

			case 'i':

				flags |= __PRINTF_FLAG_SIGNED;

			case 'u':

				break;

			case 'X':

				flags |= __PRINTF_FLAG_BIGCHARS;

			case 'x':

				base = 16;

				break;

			/* Percentile itself */

			case '%':

				j = i;

				goto next_char;

			/*

			 * Bad formatting.

			 */

			default:

				/*

				 * Unknown format. Now, j is the index of '%'

				 * so we will print whole bad format sequence.

				 */

				goto next_char;

			}

			/* Print integers */

			size_t size;

			uint64_t number;

			switch (qualifier) {

			case PrintfQualifierByte:

				size = sizeof(unsigned char);

				number = (uint64_t) va_arg(ap, unsigned int);

				break;

			case PrintfQualifierShort:

				size = sizeof(unsigned short);

				number = (uint64_t) va_arg(ap, unsigned int);

				break;

			case PrintfQualifierInt:

				size = sizeof(unsigned int);

				number = (uint64_t) va_arg(ap, unsigned int);

				break;

			case PrintfQualifierLong:

				size = sizeof(unsigned long);

				number = (uint64_t) va_arg(ap, unsigned long);

				break;

			case PrintfQualifierLongLong:

				size = sizeof(unsigned long long);

				number = (uint64_t) va_arg(ap, unsigned long long);

				break;

			case PrintfQualifierPointer:

				size = sizeof(void *);

				number = (uint64_t) (unsigned long) va_arg(ap, void *);

				break;

			default:

				/* Unknown qualifier */

				counter = -counter;

				goto out;

			}

			if (flags & __PRINTF_FLAG_SIGNED) {

				if (number & (0x1 << (size * 8 - 1))) {

					flags |= __PRINTF_FLAG_NEGATIVE;

					if (size == sizeof(uint64_t)) {

						number = -((int64_t) number);

					} else {

						number = ~number;

						number &=

						    ~(0xFFFFFFFFFFFFFFFFll <<

						    (size * 8));

						number++;

					}

				}

			}

			if ((retval = print_number(number, width, precision,

			    base, flags, ps)) < 0) {

				counter = -counter;

				goto out;

			}

			counter += retval;

			j = nxt;

		}

next_char:

		;

	}

	if (i > j) {

		if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {

			/* Error */

			counter = -counter;

			goto out;

		}

		counter += retval;

	}

out:

	return ((int) counter);

}

/** @}

 */