1/***************************************************************************/
2/*                                                                         */
3/*  ftdebug.c                                                              */
4/*                                                                         */
5/*    Debugging and logging component for WinCE (body).                    */
6/*                                                                         */
7/*  Copyright 1996-2018 by                                                 */
8/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9/*                                                                         */
10/*  This file is part of the FreeType project, and may only be used,       */
11/*  modified, and distributed under the terms of the FreeType project      */
12/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
13/*  this file you indicate that you have read the license and              */
14/*  understand and accept it fully.                                        */
15/*                                                                         */
16/***************************************************************************/
17
18
19  /*************************************************************************/
20  /*                                                                       */
21  /* This component contains various macros and functions used to ease the */
22  /* debugging of the FreeType engine.  Its main purpose is in assertion   */
23  /* checking, tracing, and error detection.                               */
24  /*                                                                       */
25  /* There are now three debugging modes:                                  */
26  /*                                                                       */
27  /* - trace mode                                                          */
28  /*                                                                       */
29  /*   Error and trace messages are sent to the log file (which can be the */
30  /*   standard error output).                                             */
31  /*                                                                       */
32  /* - error mode                                                          */
33  /*                                                                       */
34  /*   Only error messages are generated.                                  */
35  /*                                                                       */
36  /* - release mode:                                                       */
37  /*                                                                       */
38  /*   No error message is sent or generated.  The code is free from any   */
39  /*   debugging parts.                                                    */
40  /*                                                                       */
41  /*************************************************************************/
42
43
44#include <ft2build.h>
45#include FT_INTERNAL_DEBUG_H
46
47
48#ifdef FT_DEBUG_LEVEL_ERROR
49
50
51#include <stdarg.h>
52#include <stdlib.h>
53#include <string.h>
54
55#include <windows.h>
56
57
58  void
59  OutputDebugStringEx( const char*  str )
60  {
61    static WCHAR  buf[8192];
62
63
64    int sz = MultiByteToWideChar( CP_ACP, 0, str, -1, buf,
65                                  sizeof ( buf ) / sizeof ( *buf ) );
66    if ( !sz )
67      lstrcpyW( buf, L"OutputDebugStringEx: MultiByteToWideChar failed" );
68
69    OutputDebugStringW( buf );
70  }
71
72
73  FT_BASE_DEF( void )
74  FT_Message( const char*  fmt,
75              ... )
76  {
77    static char  buf[8192];
78    va_list      ap;
79
80
81    va_start( ap, fmt );
82    vfprintf( stderr, fmt, ap );
83    /* send the string to the debugger as well */
84    vsprintf( buf, fmt, ap );
85    OutputDebugStringEx( buf );
86    va_end( ap );
87  }
88
89
90  FT_BASE_DEF( void )
91  FT_Panic( const char*  fmt,
92            ... )
93  {
94    static char  buf[8192];
95    va_list      ap;
96
97
98    va_start( ap, fmt );
99    vsprintf( buf, fmt, ap );
100    OutputDebugStringEx( buf );
101    va_end( ap );
102
103    exit( EXIT_FAILURE );
104  }
105
106
107  /* documentation is in ftdebug.h */
108
109  FT_BASE_DEF( int )
110  FT_Throw( FT_Error     error,
111            int          line,
112            const char*  file )
113  {
114    FT_UNUSED( error );
115    FT_UNUSED( line );
116    FT_UNUSED( file );
117
118    return 0;
119  }
120
121#ifdef FT_DEBUG_LEVEL_TRACE
122
123
124  /* array of trace levels, initialized to 0 */
125  int  ft_trace_levels[trace_count];
126
127  /* define array of trace toggle names */
128#define FT_TRACE_DEF( x )  #x ,
129
130  static const char*  ft_trace_toggles[trace_count + 1] =
131  {
132#include FT_INTERNAL_TRACE_H
133    NULL
134  };
135
136#undef FT_TRACE_DEF
137
138
139  /*************************************************************************/
140  /*                                                                       */
141  /* Initialize the tracing sub-system.  This is done by retrieving the    */
142  /* value of the "FT2_DEBUG" environment variable.  It must be a list of  */
143  /* toggles, separated by spaces, `;' or `,'.  Example:                   */
144  /*                                                                       */
145  /*    "any:3 memory:6 stream:5"                                          */
146  /*                                                                       */
147  /* This will request that all levels be set to 3, except the trace level */
148  /* for the memory and stream components which are set to 6 and 5,        */
149  /* respectively.                                                         */
150  /*                                                                       */
151  /* See the file `include/freetype/internal/fttrace.h' for details of the */
152  /* available toggle names.                                               */
153  /*                                                                       */
154  /* The level must be between 0 and 6; 0 means quiet (except for serious  */
155  /* runtime errors), and 6 means _very_ verbose.                          */
156  /*                                                                       */
157  FT_BASE_DEF( void )
158  ft_debug_init( void )
159  {
160    /* Windows Mobile doesn't have environment API:           */
161    /* GetEnvironmentStrings, GetEnvironmentVariable, getenv. */
162    /*                                                        */
163    /* FIXME!!! How to set debug mode?                        */
164
165    /* const char*  ft2_debug = getenv( "FT2_DEBUG" ); */
166
167    const char*  ft2_debug = 0;
168
169
170    if ( ft2_debug )
171    {
172      const char*  p = ft2_debug;
173      const char*  q;
174
175
176      for ( ; *p; p++ )
177      {
178        /* skip leading whitespace and separators */
179        if ( *p == ' ' || *p == '\t' || *p == ',' || *p == ';' || *p == '=' )
180          continue;
181
182        /* read toggle name, followed by ':' */
183        q = p;
184        while ( *p && *p != ':' )
185          p++;
186
187        if ( !*p )
188          break;
189
190        if ( *p == ':' && p > q )
191        {
192          int  n, i, len = (int)( p - q );
193          int  level = -1, found = -1;
194
195
196          for ( n = 0; n < trace_count; n++ )
197          {
198            const char*  toggle = ft_trace_toggles[n];
199
200
201            for ( i = 0; i < len; i++ )
202            {
203              if ( toggle[i] != q[i] )
204                break;
205            }
206
207            if ( i == len && toggle[i] == 0 )
208            {
209              found = n;
210              break;
211            }
212          }
213
214          /* read level */
215          p++;
216          if ( *p )
217          {
218            level = *p - '0';
219            if ( level < 0 || level > 7 )
220              level = -1;
221          }
222
223          if ( found >= 0 && level >= 0 )
224          {
225            if ( found == trace_any )
226            {
227              /* special case for "any" */
228              for ( n = 0; n < trace_count; n++ )
229                ft_trace_levels[n] = level;
230            }
231            else
232              ft_trace_levels[found] = level;
233          }
234        }
235      }
236    }
237  }
238
239
240#else  /* !FT_DEBUG_LEVEL_TRACE */
241
242
243  FT_BASE_DEF( void )
244  ft_debug_init( void )
245  {
246    /* nothing */
247  }
248
249
250#endif /* !FT_DEBUG_LEVEL_TRACE */
251
252#endif /* FT_DEBUG_LEVEL_ERROR */
253
254
255/* END */
256