/***************************************************************************/

/*                                                                         */

/*  ftdebug.c                                                              */

/*                                                                         */

/*    Debugging and logging component for Win32 (body).                    */

/*                                                                         */

/*  Copyright 1996-2001, 2002, 2005, 2008, 2009 by                         */

/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */

/*                                                                         */

/*  This file is part of the FreeType project, and may only be used,       */

/*  modified, and distributed under the terms of the FreeType project      */

/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */

/*  this file you indicate that you have read the license and              */

/*  understand and accept it fully.                                        */

/*                                                                         */

/***************************************************************************/

  /*************************************************************************/

  /*                                                                       */

  /* This component contains various macros and functions used to ease the */

  /* debugging of the FreeType engine.  Its main purpose is in assertion   */

  /* checking, tracing, and error detection.                               */

  /*                                                                       */

  /* There are now three debugging modes:                                  */

  /*                                                                       */

  /* - trace mode                                                          */

  /*                                                                       */

  /*   Error and trace messages are sent to the log file (which can be the */

  /*   standard error output).                                             */

  /*                                                                       */

  /* - error mode                                                          */

  /*                                                                       */

  /*   Only error messages are generated.                                  */

  /*                                                                       */

  /* - release mode:                                                       */

  /*                                                                       */

  /*   No error message is sent or generated.  The code is free from any   */

  /*   debugging parts.                                                    */

  /*                                                                       */

  /*************************************************************************/

#include <ft2build.h>

#include FT_INTERNAL_DEBUG_H

#ifdef FT_DEBUG_LEVEL_ERROR

#include <stdarg.h>

#include <stdlib.h>

#include <string.h>

#include <windows.h>

  FT_BASE_DEF( void )

  FT_Message( const char*  fmt, ... )

  {

    static char  buf[8192];

    va_list      ap;

    va_start( ap, fmt );

    vprintf( fmt, ap );

    /* send the string to the debugger as well */

    vsprintf( buf, fmt, ap );

    OutputDebugStringA( buf );

    va_end( ap );

  }

  FT_BASE_DEF( void )

  FT_Panic( const char*  fmt, ... )

  {

    static char  buf[8192];

    va_list      ap;

    va_start( ap, fmt );

    vsprintf( buf, fmt, ap );

    OutputDebugStringA( buf );

    va_end( ap );

    exit( EXIT_FAILURE );

  }

#ifdef FT_DEBUG_LEVEL_TRACE

  /* array of trace levels, initialized to 0 */

  int  ft_trace_levels[trace_count];

  /* define array of trace toggle names */

#define FT_TRACE_DEF( x )  #x ,

  static const char*  ft_trace_toggles[trace_count + 1] =

  {

#include FT_INTERNAL_TRACE_H

    NULL

  };

#undef FT_TRACE_DEF

  /*************************************************************************/

  /*                                                                       */

  /* Initialize the tracing sub-system.  This is done by retrieving the    */

  /* value of the "FT2_DEBUG" environment variable.  It must be a list of  */

  /* toggles, separated by spaces, `;' or `,'.  Example:                   */

  /*                                                                       */

  /*    "any:3 memory:6 stream:5"                                          */

  /*                                                                       */

  /* This will request that all levels be set to 3, except the trace level */

  /* for the memory and stream components which are set to 6 and 5,        */

  /* respectively.                                                         */

  /*                                                                       */

  /* See the file <freetype/internal/fttrace.h> for details of the         */

  /* available toggle names.                                               */

  /*                                                                       */

  /* The level must be between 0 and 6; 0 means quiet (except for serious  */

  /* runtime errors), and 6 means _very_ verbose.                          */

  /*                                                                       */

  FT_BASE_DEF( void )

  ft_debug_init( void )

  {

    const char*  ft2_debug = getenv( "FT2_DEBUG" );

    if ( ft2_debug )

    {

      const char*  p = ft2_debug;

      const char*  q;

      for ( ; *p; p++ )

      {

        /* skip leading whitespace and separators */

        if ( *p == ' ' || *p == '\t' || *p == ',' || *p == ';' || *p == '=' )

          continue;

        /* read toggle name, followed by ':' */

        q = p;

        while ( *p && *p != ':' )

          p++;

        if ( *p == ':' && p > q )

        {

          int  n, i, len = p - q;

          int  level = -1, found = -1;

          for ( n = 0; n < trace_count; n++ )

          {

            const char*  toggle = ft_trace_toggles[n];

            for ( i = 0; i < len; i++ )

            {

              if ( toggle[i] != q[i] )

                break;

            }

            if ( i == len && toggle[i] == 0 )

            {

              found = n;

              break;

            }

          }

          /* read level */

          p++;

          if ( *p )

          {

            level = *p++ - '0';

            if ( level < 0 || level > 7 )

              level = -1;

          }

          if ( found >= 0 && level >= 0 )

          {

            if ( found == trace_any )

            {

              /* special case for "any" */

              for ( n = 0; n < trace_count; n++ )

                ft_trace_levels[n] = level;

            }

            else

              ft_trace_levels[found] = level;

          }

        }

      }

    }

  }

#else  /* !FT_DEBUG_LEVEL_TRACE */

  FT_BASE_DEF( void )

  ft_debug_init( void )

  {

    /* nothing */

  }

#endif /* !FT_DEBUG_LEVEL_TRACE */

#endif /* FT_DEBUG_LEVEL_ERROR */

/* END */