Context Navigation

source: mainline/src/debug/print.c@ 51022e9b

Visit:

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export

Last change on this file since 51022e9b was 51022e9b, checked in by Josef Cejka <malyzelenyhnus@…>, 20 years ago
E option in printf added.
Property mode set to `100644`
File size: 9.3 KB

Rev	Line
[f761f1eb]	1	/*
	2	* Copyright (C) 2001-2004 Jakub Jermar
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	*
	9	* - Redistributions of source code must retain the above copyright
	10	* notice, this list of conditions and the following disclaimer.
	11	* - Redistributions in binary form must reproduce the above copyright
	12	* notice, this list of conditions and the following disclaimer in the
	13	* documentation and/or other materials provided with the distribution.
	14	* - The name of the author may not be used to endorse or promote products
	15	* derived from this software without specific prior written permission.
	16	*
	17	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
	18	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
	19	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
	20	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
	21	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
	22	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	23	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	24	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	25	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
	26	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	27	*/
	28
	29	#include <putchar.h>
	30	#include <print.h>
	31	#include <synch/spinlock.h>
[0d2f805]	32	#include <arch/arg.h>
[18e0a6c]	33	#include <arch/asm.h>
[e83a9f7]	34	#include <arch/fmath.h>
[0d2f805]	35
[e83a9f7]	36	#include <arch.h>
[f761f1eb]	37
[724b58a]	38	static char digits[] = "0123456789abcdef"; /*< Hexadecimal characters /
	39	static spinlock_t printflock; /*< printf spinlock /
[f761f1eb]	40
[e83a9f7]	41	#define DEFAULT_DOUBLE_PRECISION 16
	42	#define DEFAULT_DOUBLE_BUFFER_SIZE 128
	43
[51022e9b]	44	void print_double(double num, __u8 modifier, __u16 precision)
[e83a9f7]	45	{
	46	double intval,intval2;
	47	int counter;
	48	int exponent,exponenttmp;
	49	unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];
	50	unsigned long in1,in2;
[51022e9b]	51
[e83a9f7]	52	/*
	53	if (fmath_is_nan(num)) {
	54	print_str("NaN");
	55	return;
	56	}
	57	*/
	58
	59	if (fmath_is_negative(num)) {
	60	putchar('-');
	61	}
	62
	63	num=fmath_abs(num);
	64
[51022e9b]	65	if ((modifier=='E')\|\|(modifier=='e')) {
	66	intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
	67	exponent=intval;
	68	if ((intval2<0.0)&&(exponent<0)) exponent--;
	69	num = num / ((fmath_dpow(10.0,exponent)));
	70
	71	print_double(num,modifier+1,precision); //modifier+1 = E => F or e => f
	72	putchar(modifier);
	73	if (exponent<0) {
	74	putchar('-');
	75	exponent*=-1;
	76	}
	77	print_number(exponent,10);
	78	return;
	79	}
	80
	81
[e83a9f7]	82	/*
	83	if (fmath_is_infinity(num)) {
	84	print_str("Inf");
	85	}
	86	*/
	87	//TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number
	88
	89	/* Here is problem with cumulative error while printing big double values -> we will divide
	90	the number with a power of 10, print new number with better method for small numbers and then print decimal point at correct position */
	91
	92	fmath_fint(fmath_get_decimal_exponent(num),&intval);
	93
	94	exponent=(intval>0.0?intval:0);
	95
	96	precision+=exponent;
	97
	98	if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
	99
	100	num=fmath_fint(num,&intval);
	101
	102	if (precision>0) {
	103	counter=precision-1;
	104	if (exponent>0) counter++;
	105
	106	if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
	107	counter=DEFAULT_DOUBLE_BUFFER_SIZE;
	108	}
	109	exponenttmp=exponent;
	110	while(counter>=0) {
	111	num *= 10.0;
	112	num = fmath_fint(num,&intval2);
	113	buf[counter--]=((int)intval2)+'0';
	114	exponenttmp--;
	115	if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
	116	}
	117	counter=precision;
	118	if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
	119	counter++;
	120	} else {
	121	counter=0;
	122	}
	123
	124	if (intval==0.0) {
	125	if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
	126	} else {
	127	in1=intval;
	128	while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
	129
	130	in2=in1;
	131	in1/=10;
	132	buf[counter]=in2-in1*10 + '0';
	133	counter++;
	134	}
	135	}
	136
	137	counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
	138	while (counter>0) {
	139	putchar(buf[--counter]);
	140	};
	141	return;
	142	}
[724b58a]	143
	144	/** Print NULL terminated string
	145	*
	146	* Print characters from str using putchar() until
	147	* \x00 character is reached.
	148	*
	149	* @param str Characters to print.
	150	*
	151	*/
[27dc170]	152	void print_str(const char *str)
[f761f1eb]	153	{
[02a99d2]	154	int i = 0;
[f761f1eb]	155	char c;
[02a99d2]	156
[f761f1eb]	157	while (c = str[i++])
[02a99d2]	158	putchar(c);
[f761f1eb]	159	}
	160
	161
[724b58a]	162	/** Print hexadecimal digits
	163	*
	164	* Print fixed count of hexadecimal digits from
	165	* the number num. The digits are printed in
	166	* natural left-to-right order starting with
	167	* the width-th digit.
	168	*
	169	* @param num Number containing digits.
	170	* @param width Count of digits to print.
	171	*
[f761f1eb]	172	*/
[81887b7]	173	void print_fixed_hex(const __u64 num, const int width)
[f761f1eb]	174	{
	175	int i;
	176
	177	for (i = width*8 - 4; i >= 0; i -= 4)
	178	putchar(digits[(num>>i) & 0xf]);
	179	}
	180
[724b58a]	181
	182	/** Print number in given base
	183	*
	184	* Print significant digits of a number in given
	185	* base.
	186	*
	187	* @param num Number to print.
	188	* @param base Base to print the number in (should
	189	* be in range 2 .. 16).
	190	*
[f761f1eb]	191	*/
[02a99d2]	192	void print_number(const __native num, const unsigned int base)
[27dc170]	193	{
	194	int val = num;
[199145a1]	195	char d[sizeof(__native)8+1]; / this is good enough even for base == 2 */
[02a99d2]	196	int i = sizeof(__native)*8-1;
	197
[f761f1eb]	198	do {
[27dc170]	199	d[i--] = digits[val % base];
	200	} while (val /= base);
[f761f1eb]	201
[199145a1]	202	d[sizeof(__native)*8] = 0;
[f761f1eb]	203	print_str(&d[i + 1]);
	204	}
	205
[724b58a]	206
	207	/** General formatted text print
	208	*
	209	* Print text formatted according the fmt parameter
	210	* and variant arguments. Each formatting directive
	211	* begins with % (percentage) character and one of the
	212	* following character:
	213	*
	214	* % Prints the percentage character.
[d7568a9f]	215	* s The next variant argument is treated as char*
[724b58a]	216	* and printed as a NULL terminated string.
[d7568a9f]	217	* c The next variant argument is treated as a single char.
[da79d0fd]	218	* p The next variant argument is treated as a maximum
	219	* bit-width integer with respect to architecture
	220	* and printed in full hexadecimal width.
	221	* P As with 'p', but '0x' is prefixed.
	222	* q The next variant argument is treated as a 64b integer
	223	* and printed in full hexadecimal width.
	224	* Q As with 'q', but '0x' is prefixed.
[d7568a9f]	225	* l The next variant argument is treated as a 32b integer
[724b58a]	226	* and printed in full hexadecimal width.
	227	* L As with 'l', but '0x' is prefixed.
[d7568a9f]	228	* w The next variant argument is treated as a 16b integer
[724b58a]	229	* and printed in full hexadecimal width.
	230	* W As with 'w', but '0x' is prefixed.
[d7568a9f]	231	* b The next variant argument is treated as a 8b integer
[724b58a]	232	* and printed in full hexadecimal width.
	233	* N As with 'b', but '0x' is prefixed.
[d7568a9f]	234	* d The next variant argument is treated as integer
[724b58a]	235	* and printed in standard decimal format (only significant
	236	* digits).
[d7568a9f]	237	* x The next variant argument is treated as integer
[724b58a]	238	* and printed in standard hexadecimal format (only significant
	239	* digits).
	240	* X As with 'x', but '0x' is prefixed.
	241	*
	242	* All other characters from fmt except the formatting directives
	243	* are printed in verbatim.
	244	*
	245	* @param fmt Formatting NULL terminated string.
	246	*
[f761f1eb]	247	*/
[27dc170]	248	void printf(const char *fmt, ...)
[f761f1eb]	249	{
[0d2f805]	250	int irqpri, i = 0;
	251	va_list ap;
	252	char c;
[51022e9b]	253
	254	__u16 precision;
	255
[0d2f805]	256	va_start(ap, fmt);
[f761f1eb]	257
	258	irqpri = cpu_priority_high();
	259	spinlock_lock(&printflock);
[0d2f805]	260
[f761f1eb]	261	while (c = fmt[i++]) {
	262	switch (c) {
	263
[51022e9b]	264
	265
[f761f1eb]	266	/* control character */
	267	case '%':
[51022e9b]	268
	269	precision = DEFAULT_DOUBLE_PRECISION;
	270	if (fmt[i]=='.') {
	271	precision=0;
	272	c=fmt[++i];
	273	while((c>='0')&&(c<='9')) {
	274	precision = precision*10 + c - '0';
	275	c=fmt[++i];
	276	}
	277
	278	}
	279
[f761f1eb]	280	switch (c = fmt[i++]) {
	281
	282	/* percentile itself */
	283	case '%':
	284	break;
	285
	286	/*
	287	* String and character conversions.
	288	*/
	289	case 's':
[0d2f805]	290	print_str(va_arg(ap, char_ptr));
[f761f1eb]	291	goto loop;
	292
	293	case 'c':
[199145a1]	294	c = (char) va_arg(ap, int);
[f761f1eb]	295	break;
	296
	297	/*
	298	* Hexadecimal conversions with fixed width.
	299	*/
[da79d0fd]	300	case 'P':
	301	print_str("0x");
	302	case 'p':
	303	print_fixed_hex(va_arg(ap, __native), sizeof(__native));
	304	goto loop;
	305
	306	case 'Q':
	307	print_str("0x");
	308	case 'q':
[81887b7]	309	print_fixed_hex(va_arg(ap, __u64), INT64);
[da79d0fd]	310	goto loop;
	311
[f761f1eb]	312	case 'L':
	313	print_str("0x");
	314	case 'l':
[0d2f805]	315	print_fixed_hex(va_arg(ap, __native), INT32);
[f761f1eb]	316	goto loop;
	317
	318	case 'W':
	319	print_str("0x");
	320	case 'w':
[0d2f805]	321	print_fixed_hex(va_arg(ap, __native), INT16);
[f761f1eb]	322	goto loop;
	323
	324	case 'B':
	325	print_str("0x");
	326	case 'b':
[0d2f805]	327	print_fixed_hex(va_arg(ap, __native), INT8);
[f761f1eb]	328	goto loop;
	329
[e83a9f7]	330	/*
	331	* Floating point conversions.
	332	*/
	333
	334	case 'F':
[51022e9b]	335	print_double(va_arg(ap, double),'F',precision);
	336	goto loop;
	337
[e83a9f7]	338	case 'f':
[51022e9b]	339	print_double(va_arg(ap, double),'f',precision);
[e83a9f7]	340	goto loop;
[51022e9b]	341
	342	case 'E':
	343	print_double(va_arg(ap, double),'E',precision);
	344	goto loop;
	345	case 'e':
	346	print_double(va_arg(ap, double),'e',precision);
	347	goto loop;
	348
[f761f1eb]	349	/*
	350	* Decimal and hexadecimal conversions.
	351	*/
	352	case 'd':
[0d2f805]	353	print_number(va_arg(ap, __native), 10);
[f761f1eb]	354	goto loop;
	355
	356	case 'X':
	357	print_str("0x");
	358	case 'x':
[0d2f805]	359	print_number(va_arg(ap, __native), 16);
[f761f1eb]	360	goto loop;
	361
	362	/*
	363	* Bad formatting.
	364	*/
	365	default:
	366	goto out;
	367	}
	368
	369	default: putchar(c);
	370	}
	371
	372	loop:
	373	;
	374	}
	375
	376	out:
	377	spinlock_unlock(&printflock);
	378	cpu_priority_restore(irqpri);
[0d2f805]	379
	380	va_end(ap);
[f761f1eb]	381	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: