Studio:Using printf - Revision history

Timd: Text replace - 'Category:Miscellaneous' to 'Category:Studio:Miscellaneous'

2009-08-21T15:35:39Z

Text replace - 'Category:Miscellaneous' to 'Category:Studio:Miscellaneous'

← Older revision		Revision as of 15:35, 21 August 2009
Line 134:		Line 134:
	</Source>		</Source>

	[[Category:Miscellaneous]]		[[Category:Studio:Miscellaneous]]

Timd: Using printf moved to Studio:Using printf

2009-08-18T23:32:48Z

Using printf moved to Studio:Using printf

← Older revision	Revision as of 23:32, 18 August 2009
(No difference)

Timd at 23:23, 10 March 2008

2008-03-10T23:23:21Z

Show changes

Timd at 17:32, 29 February 2008

2008-02-29T17:32:06Z

← Older revision		Revision as of 17:32, 29 February 2008
Line 119:		Line 119:
	#endif<br>		#endif<br>
	#endif /* STRIDE_PRINTF_SCL_H */<br>		#endif /* STRIDE_PRINTF_SCL_H */<br>

			[[Category:Miscellaneous]]

Root at 23:55, 5 February 2008

2008-02-05T23:55:24Z

← Older revision		Revision as of 23:55, 5 February 2008
Line 119:		Line 119:
	#endif<br>		#endif<br>
	#endif /* STRIDE_PRINTF_SCL_H */<br>		#endif /* STRIDE_PRINTF_SCL_H */<br>



	~~[[Category:Application Notes]]~~

Root at 23:46, 4 February 2008

2008-02-04T23:46:09Z

← Older revision		Revision as of 23:46, 4 February 2008
Line 122:		Line 122:


	[[Category:~~SCL~~]]		[[Category:Application Notes]]

Root at 21:52, 11 December 2007

2007-12-11T21:52:17Z

← Older revision		Revision as of 21:52, 11 December 2007
Line 122:		Line 122:


	[[Category:KB]]		[[Category:SCL]]

Root at 22:56, 21 June 2007

2007-06-21T22:56:40Z

← Older revision		Revision as of 22:56, 21 June 2007
Line 119:		Line 119:
	#endif<br>		#endif<br>
	#endif /* STRIDE_PRINTF_SCL_H */<br>		#endif /* STRIDE_PRINTF_SCL_H */<br>



			[[Category:KB]]

Root at 22:17, 18 June 2007

2007-06-18T22:17:37Z

← Older revision		Revision as of 22:17, 18 June 2007
Line 18:		Line 18:
	Now we have to implement the stride_printf function. Since we replaced printf,we have to address variable arguments. The following example demonstrates a possible implementation:<br>		Now we have to implement the stride_printf function. Since we replaced printf,we have to address variable arguments. The following example demonstrates a possible implementation:<br>
	<tt>static __inline srWORD stride_printf(char *s, ...)		<tt>static __inline srWORD stride_printf(char *s, ...)
	{		{
	srWORD ret;<br>		srWORD ret;<br>
	va_list args;<br>		va_list args;<br>
Line 26:		Line 26:
	ret = srTraceStr (wSTID, (srCHAR*) str, srLEVEL_0);<br>		ret = srTraceStr (wSTID, (srCHAR*) str, srLEVEL_0);<br>
	return ret;<br>		return ret;<br>
	}</tt>		}</tt>

	In the above example, the intercept module STID (wSTID) was used.		In the above example, the intercept module STID (wSTID) was used.
Line 32:		Line 32:
	Now that we have made the change, the printf output will go to the STRIDE trace view — however, what if STRIDE is not being used but you still want to see the printf output? This can be done simply by adding a small function which allows switching between the normal printf and stride_printf; by exposing this interface in STRIDE, the output can be controlled regardless of whether or not you are using STRIDE.		Now that we have made the change, the printf output will go to the STRIDE trace view — however, what if STRIDE is not being used but you still want to see the printf output? This can be done simply by adding a small function which allows switching between the normal printf and stride_printf; by exposing this interface in STRIDE, the output can be controlled regardless of whether or not you are using STRIDE.
	<tt>void stride_printf_set(stride_printf_flag_t flag)		<tt>void stride_printf_set(stride_printf_flag_t flag)
	{<br>		{<br>
	stride_printf_on = flag;<br>		stride_printf_on = flag;<br>
	}</tt><br>		}</tt><br>

	Now the STRIDE printf function has to change slightly to add a “normal” printf:<br>		Now the STRIDE printf function has to change slightly to add a “normal” printf:<br>
	<tt>srWORD stride_printf(char *s, ...)		<tt>srWORD stride_printf(char *s, ...)
	{<br>		{<br>
	srWORD ret = srOK;<br>		srWORD ret = srOK;<br>
	va_list args;<br>		va_list args;<br>
Line 54:		Line 54:
	} <br>		} <br>
	return ret;<br>		return ret;<br>
	}</tt>		}</tt>

	'''Sample header files'''<br>		'''Sample header files'''<br>
Line 61:		Line 61:
	'''Redefining printf to stride_printf'''<br>		'''Redefining printf to stride_printf'''<br>
	This header file should be included in one of the general include files, which in turn is included in all the source files to limit source code modifications.		This header file should be included in one of the general include files, which in turn is included in all the source files to limit source code modifications.
	<tt>#ifndef STRIDE_PRINTF_H<br>		<tt>#ifndef STRIDE_PRINTF_H<br>
	#define STRIDE_PRINTF_H<br>		#define STRIDE_PRINTF_H<br>
	#ifdef __cplusplus<br>		#ifdef __cplusplus<br>
Line 79:		Line 79:
	'''Implementing stride_printf as an inline function and SCL pragmas'''<br>		'''Implementing stride_printf as an inline function and SCL pragmas'''<br>
	The stride_printf_scl.h file is included in the STRIDE workspace. It contains the stride_printf implementation as an inline function as well as the SCL pragmas for STRIDE.<br>		The stride_printf_scl.h file is included in the STRIDE workspace. It contains the stride_printf implementation as an inline function as well as the SCL pragmas for STRIDE.<br>
	<tt>#ifndef STRIDE_PRINTF_SCL_H<br>		<tt>#ifndef STRIDE_PRINTF_SCL_H<br>
	#define STRIDE_PRINTF_SCL_H<br>		#define STRIDE_PRINTF_SCL_H<br>
	#ifdef __cplusplus<br>		#ifdef __cplusplus<br>

Root at 22:15, 18 June 2007

2007-06-18T22:15:51Z

New page

In some cases, printf is a quick and easy way to add debug information to your code. When using STRIDE, it is helpful to have the printf output redirected to the trace view window, so that the printf output is in sequence with all the function calls, messages, and trace points. Having printf output sent to the trace views not only consolidates all the debug information into one place — the trace view — it also helps to understand the sequence of events.

STRIDE provides a simple runtime command, srTraceStr, which sends strings to the trace window; however, replacing printf statements with srTraceStr in the source code can require a great deal of effort, which may not be worth it. A much simpler option is to use a macro definition to globally replace printf with srTraceStr. In addition, srTraceStr and printf's argument lists do not match exactly; therefore, parameter mapping is required. srTraceStr's syntax is as follows: 
<tt>srEXPORT srWORD srSTDCALL srTraceStr( srWORD wSTID,
srCHAR *szString,
srLevel_e eLevel );</tt>

szString is the string to be displayed in the trace view. In addition, srTraceStr contains a filtering level for the host trace view. Since printf does not offer any level of trace view filtering, it can be mapped to a single level. In most cases, level 0 is appropriate since there is no need to filter printf statements; usually you want to see them, as they are generally there for a reason.

srTraceStr's other parameter, wSTID, is a bit more complicated. A STID has to be created before srTraceStr can be called. The following two options are available:
*A STID specific to the printf tracing could be created in the target initialization code. In other words, the “STRIDE printf” would have its own STID, allowing it to be easily filtered out in the trace view if required.
*Alternately, the STID used for the intercept module could be reused. Since the scope of the “IM STID” is limited to the xxxIM.c file, the “STRIDE printf” would have to be part of this file. The intercept module is automatically generated, and therefore should not be modified; however, the example below demonstrates how the “IM STID” can be reused without having to modify the automatically-generated intercept module code.

The following macro replaces printf with a function called stride_printf : 
<tt>#define printf stride_printf</tt>

Now we have to implement the stride_printf function. Since we replaced printf,we have to address variable arguments. The following example demonstrates a possible implementation: 
<tt>static __inline srWORD stride_printf(char *s, ...)
{
srWORD ret; 
va_list args; 
char str[MAX_STRIDE_PRINTF_SIZE]; 
va_start(args, s); 
sprintf(str, s, args); 
ret = srTraceStr (wSTID, (srCHAR*) str, srLEVEL_0); 
return ret; 
}</tt>

In the above example, the intercept module STID (wSTID) was used.

Now that we have made the change, the printf output will go to the STRIDE trace view — however, what if STRIDE is not being used but you still want to see the printf output? This can be done simply by adding a small function which allows switching between the normal printf and stride_printf; by exposing this interface in STRIDE, the output can be controlled regardless of whether or not you are using STRIDE.
<tt>void stride_printf_set(stride_printf_flag_t flag)
{ 
stride_printf_on = flag; 
}</tt> 

Now the STRIDE printf function has to change slightly to add a “normal” printf: 
<tt>srWORD stride_printf(char *s, ...)
{ 
srWORD ret = srOK; 
va_list args; 
char str[MAX_STRIDE_PRINTF_SIZE]; 
va_start(args, s); 
if ((!(stride_printf_on & STRIDE_PRINTF)) || 
(stride_printf_on & OS_PRINTF)) 
{ 
printf(s, args); 
} 
if (stride_printf_on & STRIDE_PRINTF) 
{ 
sprintf(str, s, args); 
ret = srTraceStr (wSTID, (srCHAR*) str, srLEVEL_0); 
} 
return ret; 
}</tt>

'''Sample header files''' 
Two header files are required in order to use printf to add debug information to your code: a header file which redefines printf to stride_printf, and a header file containing the stride_printf implementation as an inline function as well as the SCL pragmas for STRIDE.

'''Redefining printf to stride_printf''' 
This header file should be included in one of the general include files, which in turn is included in all the source files to limit source code modifications.
<tt>#ifndef STRIDE_PRINTF_H 
#define STRIDE_PRINTF_H 
#ifdef __cplusplus 
extern "C" { 
#endif 
#define MAX_STRIDE_PRINTF_SIZE 255 
#define OS_PRINTF 1 
#define STRIDE_PRINTF 2 
extern srWORD stride_printf(char *s); 
/* Redefine printf to stride_printf */ 
#define printf stride_printf 
#ifdef __cplusplus 
} 
#endif 
#endif /* STRIDE_PRINTF_H */</tt> 

'''Implementing stride_printf as an inline function and SCL pragmas''' 
The stride_printf_scl.h file is included in the STRIDE workspace. It contains the stride_printf implementation as an inline function as well as the SCL pragmas for STRIDE. 
<tt>#ifndef STRIDE_PRINTF_SCL_H 
#define STRIDE_PRINTF_SCL_H 
#ifdef __cplusplus 
extern "C" { 
#endif 
#include <stdio.h> 
#include <stdarg.h> 
#include "stride_printf.h" 
static unsigned char stride_printf_on = OS_PRINTF; 
extern srWORD wSTID; 
static __inline void stride_printf_set(unsigned char flag) 
{ 
stride_printf_on = flag; 
} 
#undef printf 
static __inline srWORD stride_printf(char *s, ...) 
{ 
srWORD ret = srOK; 
va_list args; 
va_start(args, s); 
if ((!(stride_printf_on & STRIDE_PRINTF)) || 
(stride_printf_on & OS_PRINTF)) 
{ 
printf(s, args); 
} 
if (stride_printf_on & STRIDE_PRINTF) 
{ 
char str[MAX_STRIDE_PRINTF_SIZE]; 
sprintf(str, s, args); 
ret = srTraceStr (wSTID, (srCHAR*) str, srLEVEL_0); 
} 
return ret; 
} 
#ifdef _SCL 
#pragma scl_function(stride_printf_set) 
#endif 
#ifdef __cplusplus 
} 
#endif 
#endif /* STRIDE_PRINTF_SCL_H */