---

rcs_prnt.cc File Reference

#include "rcs_defs.hh"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include "rcs_prnt.hh"
#include "linklist.hh"

Include dependency graph for rcs_prnt.cc:

Go to the source code of this file.

Defines
#define	DEBUG_MALLOC(x)   malloc(x)
#define	DEBUG_FREE(x)   free(x)
Functions
double RCS_EXPORT	etime (void)
	void (RCS_PASCAL RCS_FAR *rcs_print_notify)()=NULL
void RCS_EXPORT	set_rcs_print_destination (RCS_PRINT_DESTINATION_TYPE _dest)
RCS_PRINT_DESTINATION_TYPE RCS_EXPORT	get_rcs_print_destination ()
char RCS_FAR **RCS_EXPORT	get_rcs_lines_table ()
RCS_LINKED_LIST RCS_FAR *RCS_EXPORT	get_rcs_print_list ()
int RCS_EXPORT	get_rcs_print_list_size ()
void RCS_EXPORT	set_rcs_print_list_sizing (int _new_max_size, LIST_SIZING_MODE _new_sizing_mode)
void RCS_EXPORT	set_rcs_print_notify (RCS_PRINT_NOTIFY_FUNC_PTR _rcs_print_notify)
void RCS_EXPORT	clean_print_list ()
void RCS_EXPORT	output_print_list (int output_func(char RCS_FAR *))
int RCS_EXPORT	count_characters_in_print_list ()
int RCS_EXPORT	count_lines_in_print_list ()
void RCS_EXPORT	convert_print_list_to_lines ()
void RCS_EXPORT	update_lines_table ()
char RCS_FAR *RCS_EXPORT	strip_control_characters (char RCS_FAR *_dest, char RCS_FAR *_src)
int RCS_EXPORT	separate_words (char RCS_FAR **_dest, int _max, char RCS_FAR *_src)
int RCS_EXPORT	rcs_vprint (char RCS_FAR *_fmt, va_list _args, int save_string)
int RCS_EXPORT	rcs_puts (char RCS_FAR *_str)
int RCS_EXPORT	rcs_fputs (char RCS_FAR *_str)
void RCS_EXPORT	close_rcs_printing ()
int RCS_EXPORT	set_rcs_print_file (char RCS_FAR *_file_name)
int RCS_EXPORT	rcs_print (char RCS_FAR *_fmt,...)
int RCS_EXPORT	set_print_rcs_error_info (const char *file, int line)
int RCS_EXPORT	print_rcs_error_new (char RCS_FAR *_fmt,...)
int RCS_EXPORT	rcs_print_debug (long flag_to_check, char RCS_FAR *_fmt,...)
void RCS_EXPORT	set_rcs_print_flag (long flag_to_set)
void RCS_EXPORT	clear_rcs_print_flag (long flag_to_clear)
int RCS_EXPORT	rcs_print_sys_error (int error_source, char RCS_FAR *_fmt,...)
int RCS_EXPORT	rcs_print_error (char RCS_FAR *_fmt,...)
Variables
RCS_LINKED_LIST RCS_FAR *	rcs_print_list = NULL
char RCS_FAR **	rcs_lines_table = NULL
RCS_PRINT_DESTINATION_TYPE	rcs_print_destination = RCS_PRINT_TO_STDOUT
int	max_rcs_errors_to_print = 30
int	rcs_errors_printed = 0
long	rcs_print_mode_flags = PRINT_RCS_ERRORS
FILE *	rcs_print_file_stream = NULL
char	rcs_print_file_name [80] = "rcs_out.txt"
char	last_error_bufs [4][100]
int	error_bufs_initialized = 0
int	last_error_buf_filled = 0
const char *	rcs_error_filename = NULL
int	rcs_error_linenum = -1

---

Define Documentation

#define DEBUG_MALLOC (  x    )     malloc(x)

Definition at line 6 of file rcs_prnt.cc.

#define DEBUG_FREE (  x    )     free(x)

Definition at line 7 of file rcs_prnt.cc.

---

Function Documentation

double RCS_EXPORT etime (  void    )

Definition at line 164 of file _timer.c. { #ifdef VXWORKS #ifdef USE_CLOCK_GETTIME double retval; struct timespec ts; #endif #ifndef POWERPC if (etime_disabled) { return (etime_disable_time); } if (global_timer_available) { return (((double) get_Global_time ()) * (1E-6)); } #endif #ifdef USE_CLOCK_GETTIME if (etime_disabled) { return (etime_disable_time); } if (clock_gettime (CLOCK_REALTIME, &ts)) { /* rcs_print_error("clock_gettime: errno = %d %s\n", errno, strerror(errno)); */ } retval = ((double) ts.tv_sec) + ((double) ts.tv_nsec) * 1e-9; return retval; #else if (etime_disabled) { return (etime_disable_time); } return ((double) tickGet ()) / ((double) sysClkRateGet ()); #endif #define ETIME_RETURNED #endif #if defined (sunos4) || defined (LYNX) || defined(irix5) || defined(sparcworks_sun4) double retval = 0.0; static double last_retval = 0.0; static struct timeval last_tp; struct timeval tp; if (etime_disabled) { return (etime_disable_time); } if (gettimeofday (&tp, NULL) == -1) { rcs_print_error ("gettimeofday failed: (errno = %d) %s\n", errno, strerror (errno)); return 0.0; } retval = ((double) tp.tv_sec) + (((double) tp.tv_usec) / 1000000.0); return (retval); #define ETIME_RETURNED #endif #if defined(sunos5) || (defined(os5) && defined(sparc)) || defined(irix6) || defined(irix64) double retval; struct timespec ts; if (etime_disabled) { return (etime_disable_time); } if (clock_gettime (CLOCK_REALTIME, &ts)) { rcs_print_error ("clock_gettime: errno = %d %s\n", errno, strerror (errno)); } retval = ((double) ts.tv_sec) + ((double) ts.tv_nsec) * 1e-9; return retval; #define ETIME_RETURNED #endif #if defined(LINUX) || defined(darwin) || defined(qnx) struct timeval tp; double retval; #if 0 static double last_retval = 0.0; #endif if (0 != gettimeofday (&tp, NULL)) { rcs_print_error ("etime: can't get time\n"); return 0.0; } retval = ((double) tp.tv_sec) + ((double) tp.tv_usec) / 1000000.0; #if 0 if (retval < last_retval) { rcs_print_error ("etime: negative time interval\n"); return 0.0; } last_retval = retval; #endif return retval; #define ETIME_RETURNED #endif /* LINUX */ #ifdef _Windows #ifdef USE_TOOL_HELP /* The TimerCount function is more accurate than the GetTickCount() function but you need toolhelp.dll which comes with Windows 3.1 but not Windows 3.0 or Windows NT */ TIMERINFO timer_info; if (etime_disabled) { return (etime_disable_time); } if (TimerCount (&timer_info)) { return ((double) timer_info.dwmsSinceStart / 1000.0); } else { rcs_print_error ("etime: TimerCount returned false.\n"); return (0); } #define ETIME_RETURNED #else /* defined(_Windows) && defined(USE_TOOL_HELP) */ #if defined(WIN32) && !defined(UNDER_CE) BOOL frequency_ok = 0; BOOL counter_ok = 0; LARGE_INTEGER frequency; LARGE_INTEGER counter; double dfreq; double dcount; #define TWO_TO_THIRTYTWO (4294967296.00) #endif if (etime_disabled) { return (etime_disable_time); } #if defined(WIN32) && !defined(UNDER_CE) frequency_ok = QueryPerformanceFrequency (&frequency); counter_ok = QueryPerformanceCounter (&counter); if (frequency_ok && counter_ok) { dfreq = frequency.HighPart * TWO_TO_THIRTYTWO + frequency.LowPart; dcount = counter.HighPart * TWO_TO_THIRTYTWO + counter.LowPart; if (dfreq > 0.0 && dcount > 0.0) { return (dcount / dfreq); } } #endif return ((double) GetTickCount () / 1000.0); #define ETIME_RETURNED #endif /* defined(_Windows) && defined(USE_TOOL_HELP) */ #endif #if defined(__MSDOS__) && !defined(_Windows) #ifndef CLOCKS_PER_SECOND #define CLOCKS_PER_SECOND CLK_TCK #endif if (etime_disabled) { return (etime_disable_time); } return clock () / CLOCKS_PER_SECOND; #define ETIME_RETURNED #endif /* __MSDOS__ */ #ifndef ETIME_RETURNED #error NO definition for etime for this platform #endif }

void (  RCS_PASCAL RCS_FAR *    RCS_PRINT_NOTIFY_FUNC_PTR )

void RCS_EXPORT set_rcs_print_destination (  RCS_PRINT_DESTINATION_TYPE    _dest )

Definition at line 109 of file rcs_prnt.cc. { if (rcs_print_destination == RCS_PRINT_TO_NULL) { rcs_errors_printed = 0; } rcs_print_destination = _dest; }

RCS_PRINT_DESTINATION_TYPE RCS_EXPORT get_rcs_print_destination (  void    )

Definition at line 119 of file rcs_prnt.cc. Referenced by nmlWaitOpen(). { return (rcs_print_destination); }

char RCS_FAR** RCS_EXPORT get_rcs_lines_table (  void    )

Definition at line 129 of file rcs_prnt.cc. Referenced by main(). { return (rcs_lines_table); }

RCS_LINKED_LIST RCS_FAR* RCS_EXPORT get_rcs_print_list (    )

Definition at line 140 of file rcs_prnt.cc. Referenced by main(). { return (rcs_print_list); }

int RCS_EXPORT get_rcs_print_list_size (  void    )

Definition at line 147 of file rcs_prnt.cc. { if (NULL != rcs_print_list) { return (rcs_print_list->list_size); } else { return (-1); } }

void RCS_EXPORT set_rcs_print_list_sizing (  int    _new_max_size, LIST_SIZING_MODE    _new_sizing_mode )

Definition at line 159 of file rcs_prnt.cc. { if (NULL == rcs_print_list) { rcs_print_list = new RCS_LINKED_LIST; } if (NULL != rcs_print_list) { rcs_print_list->set_list_sizing_mode (_new_max_size, _new_sizing_mode); } }

void RCS_EXPORT set_rcs_print_notify (  RCS_PRINT_NOTIFY_FUNC_PTR    _rcs_print_notify )

Definition at line 172 of file rcs_prnt.cc. { rcs_print_notify = _rcs_print_notify; }

void RCS_EXPORT clean_print_list (  void    )

Definition at line 178 of file rcs_prnt.cc. Referenced by close_rcs_printing(). { if (NULL != rcs_print_list) { delete rcs_print_list; rcs_print_list = NULL; } }

void RCS_EXPORT output_print_list (  int output_func(char RCS_FAR *)    )

Definition at line 188 of file rcs_prnt.cc. { if (NULL != rcs_print_list) { char *string_from_list; string_from_list = (char *) rcs_print_list->get_head (); while (NULL != string_from_list) { if (output_func (string_from_list) != EOF) { break; } string_from_list = (char *) rcs_print_list->get_next (); } } }

int RCS_EXPORT count_characters_in_print_list (  void    )

Definition at line 206 of file rcs_prnt.cc. { int count = 0; if (NULL != rcs_print_list) { char *string_from_list; string_from_list = (char *) rcs_print_list->get_head (); while (NULL != string_from_list) { count += strlen (string_from_list); string_from_list = (char *) rcs_print_list->get_next (); } } return (count); }

int RCS_EXPORT count_lines_in_print_list (  void    )

Definition at line 223 of file rcs_prnt.cc. { int count = 1; if (NULL != rcs_print_list) { char *string_from_list; string_from_list = (char *) rcs_print_list->get_head (); while (NULL != string_from_list) { char *line; line = strchr (string_from_list, '\n'); while (NULL != line) { count++; line = strchr (line + 1, '\n'); } string_from_list = (char *) rcs_print_list->get_next (); } } return (count); }

void RCS_EXPORT convert_print_list_to_lines (  void    )

Definition at line 246 of file rcs_prnt.cc. Referenced by update_lines_table(). { char *temp_buf = NULL; static int last_id_converted = -1; if (NULL != rcs_print_list) { char *string_from_list; if (-1 == last_id_converted) { string_from_list = (char *) rcs_print_list->get_head (); } else { string_from_list = (char *) rcs_print_list->get_first_newer (last_id_converted); } while (NULL != string_from_list) { char *next_line; next_line = strchr (string_from_list, '\n'); if (NULL == next_line) { if (NULL == temp_buf) { temp_buf = (char *) malloc (strlen (string_from_list) + 1); strcpy (temp_buf, string_from_list); } else { temp_buf = (char *) realloc (temp_buf, strlen (temp_buf) + strlen (string_from_list) + 1); strcat (temp_buf, string_from_list); } rcs_print_list->delete_current_node (); } else { if (temp_buf != NULL) { temp_buf = (char *) realloc (temp_buf, strlen (temp_buf) + strlen (string_from_list) + 1); strcat (temp_buf, string_from_list); rcs_print_list->delete_current_node (); rcs_print_list->store_after_current_node (temp_buf, strlen (temp_buf) + 1, 1); DEBUG_FREE (temp_buf); temp_buf = NULL; } else if (next_line[1] != 0) { rcs_print_list->store_after_current_node (next_line + 1, strlen (next_line + 1) + 1, 1); next_line[1] = 0; } } string_from_list = (char *) rcs_print_list->get_next (); } } last_id_converted = rcs_print_list->get_newest_id (); if (temp_buf != NULL) { rcs_print_list->store_at_tail (temp_buf, strlen (temp_buf) + 1, 1); DEBUG_FREE (temp_buf); temp_buf = NULL; } }

void RCS_EXPORT update_lines_table (  void    )

Definition at line 321 of file rcs_prnt.cc. Referenced by main(). { if (NULL != rcs_lines_table) { DEBUG_FREE (rcs_lines_table); rcs_lines_table = NULL; } if (NULL != rcs_print_list) { convert_print_list_to_lines (); rcs_lines_table = (char RCS_FAR **) malloc (sizeof (char *) * rcs_print_list->list_size); if (NULL != rcs_print_list) { char *string_from_list; string_from_list = (char *) rcs_print_list->get_head (); int i = 0; while (NULL != string_from_list) { rcs_lines_table[i] = string_from_list; i++; string_from_list = (char *) rcs_print_list->get_next (); } } } }

char RCS_FAR* RCS_EXPORT strip_control_characters (  char RCS_FAR *    _dest, char RCS_FAR *    _src )

Definition at line 354 of file rcs_prnt.cc. { static char line_buffer[255]; char *destination; #ifndef UNDER_CE char *control_char_loc; if (NULL == _dest) { destination = line_buffer; if (strlen (_src) < 255) { strcpy (line_buffer, _src); } else { if (NULL == strpbrk (_src, "\n\r\t\b")) { return (_src); } else { return (NULL); } } } else { destination = _dest; if (_dest != _src) { #ifndef __CENTERLINE__ /* CenterLine messed up string.h for C++ so that memmove will be undefined. */ memmove (_dest, _src, strlen (_src)); #else strcpy (line_buffer, _src); strcpy (_dest, line_buffer); #endif } } control_char_loc = strpbrk (destination, "\n\r\t\b"); while (NULL != control_char_loc) { *control_char_loc = ' '; /* Replace control character with SPACE */ control_char_loc = strpbrk (control_char_loc, "\n\r\t\b"); } #else if (NULL == _dest) { destination = line_buffer; } else { destination = _dest; } strcpy (destination, _src); #endif return (destination); }

int RCS_EXPORT separate_words (  char RCS_FAR **    _dest, int    _max, char RCS_FAR *    _src )

Definition at line 420 of file rcs_prnt.cc. { static char word_buffer[256]; int i; if (NULL == _dest || NULL == _src) { return -1; } if (strlen (_src) > 255) { return -1; } strcpy (word_buffer, _src); _dest[0] = strtok (word_buffer, " \n\r\t"); for (i = 0; NULL != _dest[i] && i < _max - 1; i++) { _dest[i + 1] = strtok (NULL, " \n\r\t"); } if (_dest[_max - 1] == NULL && i == _max - 1) { i--; } return (i + 1); }

int RCS_EXPORT rcs_vprint (  char RCS_FAR *    _fmt, va_list    va_args, int    save_string )

Definition at line 446 of file rcs_prnt.cc. { static char temp_string[256]; if (NULL == _fmt) { return (EOF); } if (strlen (_fmt) > 200) /* Might overflow temp_string. */ { return (EOF); } #ifndef UNDER_CE if (EOF == (int) vsprintf (temp_string, _fmt, _args)) { return (EOF); } #else if (EOF == (int) RCS_CE_VSPRINTF (temp_string, _fmt, _args)) { return (EOF); } #endif if (save_string) { if (!error_bufs_initialized) { memset (last_error_bufs[0], 0, 100); memset (last_error_bufs[1], 0, 100); memset (last_error_bufs[2], 0, 100); memset (last_error_bufs[3], 0, 100); error_bufs_initialized = 1; } last_error_buf_filled++; last_error_buf_filled %= 4; strncpy (last_error_bufs[last_error_buf_filled], temp_string, 99); } return (rcs_fputs (temp_string)); }

int RCS_EXPORT rcs_puts (  char RCS_FAR *    _str )

Definition at line 487 of file rcs_prnt.cc. { int retval, retval2; retval = rcs_fputs (_str); if (retval != EOF) { retval2 = rcs_fputs ("\n"); if (retval2 != EOF) { retval += retval; } else { retval = EOF; } } return (retval); }

int RCS_EXPORT rcs_fputs (  char RCS_FAR *    _str )

Definition at line 507 of file rcs_prnt.cc. { int retval = EOF; if (NULL != _str) { if (0 == _str[0]) { return (0); } switch (rcs_print_destination) { #ifdef VXWORKS case RCS_PRINT_TO_LOGGER: retval = logMsg (_str, 0, 0, 0, 0, 0, 0); break; #else case RCS_PRINT_TO_LOGGER: #endif case RCS_PRINT_TO_STDOUT: #ifndef _WINDLL #ifdef UNDER_CE #ifdef UNICODE wchar_t wstr[256]; RCS_CE_ASCII_TO_UNICODE (wstr, _str, 256); OutputDebugString (wstr); #else OutputDebugString (_str); #endif #else #ifdef WIN32 if (!AllocConsoleCalled) { AllocConsoleRetVal = AllocConsole (); AllocConsoleCalled = TRUE; } OutputHandle = GetStdHandle (STD_OUTPUT_HANDLE); if (NULL == OutputHandle) { retval = fputs (_str, stdout); fflush (stdout); } else { DWORD bytes_written; WriteConsole (OutputHandle, _str, strlen (_str), (LPDWORD) & bytes_written, NULL); retval = (int) bytes_written; } #else retval = fputs (_str, stdout); fflush (stdout); #endif #endif #endif break; case RCS_PRINT_TO_STDERR: #ifndef UNDER_CE retval = fputs (_str, stderr); fflush (stderr); #endif break; case RCS_PRINT_TO_LIST: if (NULL == rcs_print_list) { rcs_print_list = new RCS_LINKED_LIST; if (NULL != rcs_print_list) { rcs_print_list->set_list_sizing_mode (256, DELETE_FROM_HEAD); } } if (NULL != rcs_print_list) { if (-1 == rcs_print_list->store_at_tail (_str, (retval = strlen (_str)) + 1, 1)) { retval = EOF; } } break; case RCS_PRINT_TO_NULL: retval = strlen (_str); break; case RCS_PRINT_TO_FILE: #ifndef UNDER_CE if (NULL == rcs_print_file_stream) { if (NULL == rcs_print_file_name) { return EOF; } rcs_print_file_stream = fopen (rcs_print_file_name, "a+"); } if (NULL == rcs_print_file_stream) { return EOF; } retval = fputs (_str, rcs_print_file_stream); fflush (rcs_print_file_stream); #endif break; #if defined(_Windows) && !defined(gnuwin32) case RCS_PRINT_TO_MESSAGE_BOX: #ifdef UNICODE wchar_t wstr2[256]; RCS_CE_ASCII_TO_UNICODE (wstr2, _str, 256); retval = strlen (_str); if (IDOK != MessageBox (NULL, wstr2, TEXT ("RCS Message"), MB_OK)) { retval = EOF; } #else retval = strlen (_str); if (IDOK != MessageBox (NULL, _str, "RCS Message", MB_OK)) { retval = EOF; } #endif break; #endif default: break; } if (NULL != rcs_print_notify) { (*rcs_print_notify) (); } } return (retval); }

void RCS_EXPORT close_rcs_printing (  void    )

Definition at line 646 of file rcs_prnt.cc. { #ifndef UNDER_CE switch (rcs_print_destination) { case RCS_PRINT_TO_LIST: clean_print_list (); break; case RCS_PRINT_TO_FILE: if (NULL != rcs_print_file_stream) { fclose (rcs_print_file_stream); rcs_print_file_stream = NULL; } break; default: break; } #endif return; }

int RCS_EXPORT set_rcs_print_file (  char RCS_FAR *    _file_name )

Definition at line 670 of file rcs_prnt.cc. { #ifndef UNDER_CE if (_file_name == NULL) { return -1; } if (strlen (_file_name) > 80) { return -1; } strcpy (rcs_print_file_name, _file_name); if (NULL != rcs_print_file_stream) { fclose (rcs_print_file_stream); } rcs_print_file_stream = fopen (rcs_print_file_name, "a+"); if (NULL == rcs_print_file_stream) { return -1; } #endif return 0; }

int RCS_EXPORT rcs_print (  char RCS_FAR *    _fmt, ...    )

Definition at line 696 of file rcs_prnt.cc. { static char temp_buffer[256]; int retval; va_list args; if (strlen (_fmt) > 250) { return EOF; } va_start (args, _fmt); #ifdef sparcworks_sun4 // this platform has vsprintf defined as // char *vsprintf(char *, const char *, va_list); // it should be // int vsprintf(char *, const char *, va_list); vsprintf (temp_buffer, _fmt, args); va_end (args); #else #ifndef UNDER_CE retval = vsprintf (temp_buffer, _fmt, args); #else retval = RCS_CE_VSPRINTF (temp_buffer, _fmt, args); #endif va_end (args); if (retval == (EOF)) { return EOF; } #endif retval = rcs_fputs (temp_buffer); return (retval); }

int RCS_EXPORT set_print_rcs_error_info (  const char *    file, int    line )

Definition at line 733 of file rcs_prnt.cc. { rcs_error_filename = file; rcs_error_linenum = line; return (0); }

int RCS_EXPORT print_rcs_error_new (  char RCS_FAR *    _fmt, ...    )

Definition at line 742 of file rcs_prnt.cc. { int retval = 0; va_list args; va_start (args, _fmt); if ((rcs_print_mode_flags & PRINT_RCS_ERRORS) && ((max_rcs_errors_to_print >= rcs_errors_printed) || max_rcs_errors_to_print < 0)) { if (NULL != rcs_error_filename && rcs_error_linenum > 0) { rcs_print ("%s %d: ", rcs_error_filename, rcs_error_linenum); rcs_error_filename = NULL; rcs_error_linenum = -1; } retval = rcs_vprint (_fmt, args, 1); if (max_rcs_errors_to_print == rcs_errors_printed && max_rcs_errors_to_print >= 0) { rcs_print ("\nMaximum number of errors to print exceeded!\n"); } } if (rcs_print_destination != RCS_PRINT_TO_NULL) { rcs_errors_printed++; } va_end (args); return (retval); }

int RCS_EXPORT rcs_print_debug (  long    flag_to_check, char RCS_FAR *    _fmt, ...    )

Definition at line 776 of file rcs_prnt.cc. { int retval = 0; int pid = 0; va_list args; va_start (args, _fmt); if (flag_to_check & rcs_print_mode_flags) { #ifdef WIN32 pid = GetCurrentProcessId (); #else #ifndef VXWORKS pid = getpid (); #else pid = taskIdSelf (); #endif #endif rcs_print ("(time=%f,pid=%d): ", etime (), pid); retval = rcs_vprint (_fmt, args, 0); } va_end (args); return (retval); }

void RCS_EXPORT set_rcs_print_flag (  long    flags_to_set )

Definition at line 802 of file rcs_prnt.cc. { rcs_print_mode_flags |= flag_to_set; }

void RCS_EXPORT clear_rcs_print_flag (  long    flags_to_set )

Definition at line 808 of file rcs_prnt.cc. { rcs_print_mode_flags &= ~(flag_to_clear); }

int RCS_EXPORT rcs_print_sys_error (  int    error_source, char RCS_FAR *    _fmt, ...    )

Definition at line 816 of file rcs_prnt.cc. { static char temp_string[256]; static char message_string[512]; va_list args; va_start (args, _fmt); if (NULL == _fmt) { return (EOF); } if (strlen (_fmt) > 200) /* Might overflow temp_string. */ { return (EOF); } #ifndef UNDER_CE if (EOF == (int) vsprintf (temp_string, _fmt, args)) { return (EOF); } #else if (EOF == (int) RCS_CE_VSPRINTF (temp_string, _fmt, args)) { return (EOF); } #endif va_end (args); if (max_rcs_errors_to_print == rcs_errors_printed && max_rcs_errors_to_print >= 0) { rcs_print ("\nMaximum number of errors to print exceeded!\n"); } rcs_errors_printed++; if (max_rcs_errors_to_print <= rcs_errors_printed && max_rcs_errors_to_print >= 0) { return (EOF); } switch (error_source) { case ERRNO_ERROR_SOURCE: #ifndef UNDER_CE sprintf (message_string, "%s %d %s\n", temp_string, errno, strerror (errno)); #endif rcs_puts (message_string); break; #ifndef UNDER_CE #ifdef WIN32 case GETLASTERROR_ERROR_SOURCE: { char *msgBuf = NULL; DWORD errCode = GetLastError (); FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, errCode, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) & msgBuf, 0, NULL); if (NULL != msgBuf) { sprintf (message_string, "%s %d %s\n", temp_string, errCode, msgBuf); } else { sprintf (message_string, "%s %d\n", temp_string, errCode); } } rcs_puts (message_string); break; case WSAGETLASTERROR_ERROR_SOURCE: { char *msgBuf = NULL; DWORD errCode = WSAGetLastError (); FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, errCode, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) & msgBuf, 0, NULL); if (NULL != msgBuf) { sprintf (message_string, "%s %d %s\n", temp_string, errCode, msgBuf); } else { sprintf (message_string, "%s %d\n", temp_string, errCode); } } rcs_puts (message_string); break; #endif #endif default: rcs_puts (temp_string); break; } return (strlen (temp_string)); }

int RCS_EXPORT rcs_print_error (  char RCS_FAR *    _fmt, ...    )

Definition at line 930 of file rcs_prnt.cc. { int retval = 0; va_list args; va_start (args, _fmt); if ((rcs_print_mode_flags & PRINT_RCS_ERRORS) && ((max_rcs_errors_to_print >= rcs_errors_printed) || max_rcs_errors_to_print < 0)) { retval = rcs_vprint (_fmt, args, 1); if (max_rcs_errors_to_print == rcs_errors_printed && max_rcs_errors_to_print >= 0) { rcs_print ("\nMaximum number of errors to print exceeded!\n"); } } if (rcs_print_destination != RCS_PRINT_TO_NULL) { rcs_errors_printed++; } va_end (args); return (retval); }

---

Variable Documentation

RCS_LINKED_LIST RCS_FAR* rcs_print_list = NULL

Definition at line 75 of file rcs_prnt.cc.

char RCS_FAR** rcs_lines_table = NULL

Definition at line 76 of file rcs_prnt.cc.

RCS_PRINT_DESTINATION_TYPE rcs_print_destination = RCS_PRINT_TO_STDOUT

Definition at line 80 of file rcs_prnt.cc.

int max_rcs_errors_to_print = 30

Definition at line 94 of file rcs_prnt.cc.

int rcs_errors_printed = 0

Definition at line 95 of file rcs_prnt.cc.

long rcs_print_mode_flags = PRINT_RCS_ERRORS

Definition at line 97 of file rcs_prnt.cc.

FILE* rcs_print_file_stream = NULL

Definition at line 99 of file rcs_prnt.cc.

char rcs_print_file_name[80] = "rcs_out.txt"

Definition at line 100 of file rcs_prnt.cc.

char last_error_bufs[4][100]

Definition at line 103 of file rcs_prnt.cc.

int error_bufs_initialized = 0

Definition at line 104 of file rcs_prnt.cc.

int last_error_buf_filled = 0

Definition at line 105 of file rcs_prnt.cc.

const char* rcs_error_filename = NULL [static]

Definition at line 730 of file rcs_prnt.cc.

int rcs_error_linenum = -1 [static]

Definition at line 731 of file rcs_prnt.cc.

---