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

/*                                                                         */

/*  ftdebug.c                                                              */

/*                                                                         */

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

/*                                                                         */

/*  Copyright 1996-2001, 2002, 2004, 2008 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_FREETYPE_H

#include FT_INTERNAL_DEBUG_H

#ifdef FT_DEBUG_LEVEL_ERROR

  /* documentation is in ftdebug.h */

  FT_BASE_DEF( void )

  FT_Message( const char*  fmt, ... )

  {

    va_list  ap;

    va_start( ap, fmt );

    vfprintf( stderr, fmt, ap );

    va_end( ap );

  }

  /* documentation is in ftdebug.h */

  FT_BASE_DEF( void )

  FT_Panic( const char*  fmt, ... )

  {

    va_list  ap;

    va_start( ap, fmt );

    vfprintf( stderr, fmt, ap );

    va_end( ap );

    exit( EXIT_FAILURE );

  }

#endif /* FT_DEBUG_LEVEL_ERROR */

#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

  /* documentation is in ftdebug.h */

  FT_BASE_DEF( FT_Int )

  FT_Trace_Get_Count( void )

  {

    return trace_count;

  }

  /* documentation is in ftdebug.h */

  FT_BASE_DEF( const char * )

  FT_Trace_Get_Name( FT_Int  idx )

  {

    int  max = FT_Trace_Get_Count();

    if ( idx < max )

      return ft_trace_toggles[idx];

    else

      return NULL;

  }

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

  /*                                                                       */

  /* 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:                  */

  /*                                                                       */

  /*    export FT2_DEBUG="any:3 memory:7 stream:5"                         */

  /*                                                                       */

  /* This requests that all levels be set to 3, except the trace level for */

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

  /* respectively.                                                         */

  /*                                                                       */

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

  /* available toggle names.                                               */

  /*                                                                       */

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

  /* runtime errors), and 7 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 )

        {

          FT_Int  n, i, len = (FT_Int)( p - q );

          FT_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 */

  }

  FT_BASE_DEF( FT_Int )

  FT_Trace_Get_Count( void )

  {

    return 0;

  }

  FT_BASE_DEF( const char * )

  FT_Trace_Get_Name( FT_Int  idx )

  {

    FT_UNUSED( idx );

    return NULL;

  }

#endif /* !FT_DEBUG_LEVEL_TRACE */

/* END */