builds/amiga/src/base/ftdebug.c

   1 /***************************************************************************/
   2 /*                                                                         */
   3 /*  ftdebug.c                                                              */
   4 /*                                                                         */
   5 /*    Debugging and logging component for amiga (body).                    */
   6 /*                                                                         */
   7 /*  Copyright 1996-2002, 2004, 2005, 2013 by                               */
   8 /*  David Turner, Robert Wilhelm, Werner Lemberg and Detlef Würkner.       */
   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   /*
  45    * Based on the default ftdebug.c,
  46    * replaced vprintf() with KVPrintF(),
  47    * commented out exit(),
  48    * replaced getenv() with GetVar().
  49    */
  50
  51 #include <exec/types.h>
  52 #include <utility/tagitem.h>
  53 #include <dos/exall.h>
  54 #include <dos/var.h>
  55 #define __NOLIBBASE__
  56 #define __NOLOBALIFACE__
  57 #define __USE_INLINE__
  58 #include <proto/dos.h>
  59 #include <clib/debug_protos.h>
  60
  61 #ifndef __amigaos4__
  62   extern struct Library *DOSBase;
  63 #else
  64   extern struct DOSIFace *IDOS;
  65 #endif
  66
  67
  68 #include <ft2build.h>
  69 #include FT_FREETYPE_H
  70 #include FT_INTERNAL_DEBUG_H
  71
  72
  73 #if defined( FT_DEBUG_LEVEL_ERROR )
  74
  75   /* documentation is in ftdebug.h */
  76
  77   FT_BASE_DEF( void )
  78   FT_Message( const char*  fmt,
  79               ... )
  80   {
  81     va_list  ap;
  82
  83
  84     va_start( ap, fmt );
  85     KVPrintF( fmt, ap );
  86     va_end( ap );
  87   }
  88
  89
  90   /* documentation is in ftdebug.h */
  91
  92   FT_BASE_DEF( void )
  93   FT_Panic( const char*  fmt,
  94             ... )
  95   {
  96     va_list  ap;
  97
  98
  99     va_start( ap, fmt );
 100     KVPrintF( fmt, ap );
 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 #endif /* FT_DEBUG_LEVEL_ERROR */
 122
 123
 124
 125 #ifdef FT_DEBUG_LEVEL_TRACE
 126
 127   /* array of trace levels, initialized to 0 */
 128   int  ft_trace_levels[trace_count];
 129
 130
 131   /* define array of trace toggle names */
 132 #define FT_TRACE_DEF( x )  #x ,
 133
 134   static const char*  ft_trace_toggles[trace_count + 1] =
 135   {
 136 #include FT_INTERNAL_TRACE_H
 137     NULL
 138   };
 139
 140 #undef FT_TRACE_DEF
 141
 142
 143   /* documentation is in ftdebug.h */
 144
 145   FT_BASE_DEF( FT_Int )
 146   FT_Trace_Get_Count( void )
 147   {
 148     return trace_count;
 149   }
 150
 151
 152   /* documentation is in ftdebug.h */
 153
 154   FT_BASE_DEF( const char * )
 155   FT_Trace_Get_Name( FT_Int  idx )
 156   {
 157     int  max = FT_Trace_Get_Count();
 158
 159
 160     if ( idx < max )
 161       return ft_trace_toggles[idx];
 162     else
 163       return NULL;
 164   }
 165
 166
 167   /*************************************************************************/
 168   /*                                                                       */
 169   /* Initialize the tracing sub-system.  This is done by retrieving the    */
 170   /* value of the `FT2_DEBUG' environment variable.  It must be a list of  */
 171   /* toggles, separated by spaces, `;', or `,'.  Example:                  */
 172   /*                                                                       */
 173   /*    export FT2_DEBUG="any:3 memory:7 stream:5"                         */
 174   /*                                                                       */
 175   /* This requests that all levels be set to 3, except the trace level for */
 176   /* the memory and stream components which are set to 7 and 5,            */
 177   /* respectively.                                                         */
 178   /*                                                                       */
 179   /* See the file <include/internal/fttrace.h> for details of the          */
 180   /* available toggle names.                                               */
 181   /*                                                                       */
 182   /* The level must be between 0 and 7; 0 means quiet (except for serious  */
 183   /* runtime errors), and 7 means _very_ verbose.                          */
 184   /*                                                                       */
 185   FT_BASE_DEF( void )
 186   ft_debug_init( void )
 187   {
 188 /*  const char*  ft2_debug = getenv( "FT2_DEBUG" ); */
 189     char         buf[256];
 190     const char*  ft2_debug = &buf[0];
 191
 192
 193 /*  if ( ft2_debug ) */
 194     if ( GetVar( "FT2_DEBUG", (STRPTR)ft2_debug, 256, LV_VAR ) > 0 )
 195     {
 196       const char*  p = ft2_debug;
 197       const char*  q;
 198
 199
 200       for ( ; *p; p++ )
 201       {
 202         /* skip leading whitespace and separators */
 203         if ( *p == ' ' || *p == '\t' || *p == ',' || *p == ';' || *p == '=' )
 204           continue;
 205
 206         /* read toggle name, followed by ':' */
 207         q = p;
 208         while ( *p && *p != ':' )
 209           p++;
 210
 211         if ( !*p )
 212           break;
 213
 214         if ( *p == ':' && p > q )
 215         {
 216           FT_Int  n, i, len = (FT_Int)( p - q );
 217           FT_Int  level = -1, found = -1;
 218
 219
 220           for ( n = 0; n < trace_count; n++ )
 221           {
 222             const char*  toggle = ft_trace_toggles[n];
 223
 224
 225             for ( i = 0; i < len; i++ )
 226             {
 227               if ( toggle[i] != q[i] )
 228                 break;
 229             }
 230
 231             if ( i == len && toggle[i] == 0 )
 232             {
 233               found = n;
 234               break;
 235             }
 236           }
 237
 238           /* read level */
 239           p++;
 240           if ( *p )
 241           {
 242             level = *p - '0';
 243             if ( level < 0 || level > 7 )
 244               level = -1;
 245           }
 246
 247           if ( found >= 0 && level >= 0 )
 248           {
 249             if ( found == trace_any )
 250             {
 251               /* special case for `any' */
 252               for ( n = 0; n < trace_count; n++ )
 253                 ft_trace_levels[n] = level;
 254             }
 255             else
 256               ft_trace_levels[found] = level;
 257           }
 258         }
 259       }
 260     }
 261   }
 262
 263
 264 #else  /* !FT_DEBUG_LEVEL_TRACE */
 265
 266
 267   FT_BASE_DEF( void )
 268   ft_debug_init( void )
 269   {
 270     /* nothing */
 271   }
 272
 273
 274   FT_BASE_DEF( FT_Int )
 275   FT_Trace_Get_Count( void )
 276   {
 277     return 0;
 278   }
 279
 280
 281   FT_BASE_DEF( const char * )
 282   FT_Trace_Get_Name( FT_Int  idx )
 283   {
 284     FT_UNUSED( idx );
 285
 286     return NULL;
 287   }
 288
 289
 290 #endif /* !FT_DEBUG_LEVEL_TRACE */
 291
 292 /*
 293 Local Variables:
 294 coding: latin-1
 295 End:
 296 */
 297 /* END */