title: Failed to Install Xdebug
body: <p>'ve registered xdebug in php.ini (as per <a href="http://xdebug.org/docs/install" rel="nofollow noreferrer">http://xdebug.org/docs/install</a>) but it's not showing up when i run "php -m" or when i get a test page to run "phpinfo()". I've just installed the latest version of XAMPP. I've used both "zend_extention" and "zend_extention_ts" to specify the path of the xdebug dll. I ensured that my apache server restarted and used the latest change of my php.ini by executing "httpd -k restart".</p>
  
  <p>Can anyone provide any suggestions in getting xdebug to show up?</p>
  
  <p>Here are the contents of my php.ini file.
      [PHP]</p>
  
  <pre><code>;;;;;;;;;;;;;;;;;;;
  ; About php.ini   ;
  ;;;;;;;;;;;;;;;;;;;
  ; PHP's initialization file, generally called php.ini, is responsible for
  ; configuring many of the aspects of PHP's behavior.
  
  ; PHP attempts to find and load this configuration from a number of locations.
  ; The following is a summary of its search order:
  ; 1. SAPI module specific location.
  ; 2. The PHPRC environment variable. (As of PHP 5.2.0)
  ; 3. A number of predefined registry keys on Windows (As of PHP 5.2.0)
  ; 4. Current working directory (except CLI)
  ; 5. The web server's directory (for SAPI modules), or directory of PHP
  ; (otherwise in Windows)
  ; 6. The directory from the --with-config-file-path compile time option, or the
  ; Windows directory (C:\windows or C:\winnt)
  ; See the PHP docs for more specific information.
  ; http://php.net/configuration.file
  
  ; The syntax of the file is extremely simple.  Whitespace and Lines
  ; beginning with a semicolon are silently ignored (as you probably guessed).
  ; Section headers (e.g. [Foo]) are also silently ignored, even though
  ; they might mean something in the future.
  
  ; Directives following the section heading [PATH=/www/mysite] only
  ; apply to PHP files in the /www/mysite directory.  Directives
  ; following the section heading [HOST=www.example.com] only apply to
  ; PHP files served from www.example.com.  Directives set in these
  ; special sections cannot be overridden by user-defined INI files or
  ; at runtime. Currently, [PATH=] and [HOST=] sections only work under
  ; CGI/FastCGI.
  ; http://php.net/ini.sections
  
  ; Directives are specified using the following syntax:
  ; directive = value
  ; Directive names are *case sensitive* - foo=bar is different from FOO=bar.
  ; Directives are variables used to configure PHP or PHP extensions.
  ; There is no name validation.  If PHP can't find an expected
  ; directive because it is not set or is mistyped, a default value will be used.
  
  ; The value can be a string, a number, a PHP constant (e.g. E_ALL or M_PI), one
  ; of the INI constants (On, Off, True, False, Yes, No and None) or an expression
  ; (e.g. E_ALL &amp; ~E_NOTICE), a quoted string ("bar"), or a reference to a
  ; previously set variable or directive (e.g. ${foo})
  
  ; Expressions in the INI file are limited to bitwise operators and parentheses:
  ; |  bitwise OR
  ; ^  bitwise XOR
  ; &amp;  bitwise AND
  ; ~  bitwise NOT
  ; !  boolean NOT
  
  ; Boolean flags can be turned on using the values 1, On, True or Yes.
  ; They can be turned off using the values 0, Off, False or No.
  
  ; An empty string can be denoted by simply not writing anything after the equal
  ; sign, or by using the None keyword:
  
  ;  foo =         ; sets foo to an empty string
  ;  foo = None    ; sets foo to an empty string
  ;  foo = "None"  ; sets foo to the string 'None'
  
  ; If you use constants in your value, and these constants belong to a
  ; dynamically loaded extension (either a PHP extension or a Zend extension),
  ; you may only use these constants *after* the line that loads the extension.
  
  ;;;;;;;;;;;;;;;;;;;
  ; About this file ;
  ;;;;;;;;;;;;;;;;;;;
  ; PHP comes packaged with two INI files. One that is recommended to be used
  ; in production environments and one that is recommended to be used in
  ; development environments.
  
  ; php.ini-production contains settings which hold security, performance and
  ; best practices at its core. But please be aware, these settings may break
  ; compatibility with older or less security conscience applications. We
  ; recommending using the production ini in production and testing environments.
  
  ; php.ini-development is very similar to its production variant, except it's
  ; much more verbose when it comes to errors. We recommending using the
  ; development version only in development environments as errors shown to
  ; application users can inadvertently leak otherwise secure information.
  
  ;;;;;;;;;;;;;;;;;;;
  ; Quick Reference ;
  ;;;;;;;;;;;;;;;;;;;
  ; The following are all the settings which are different in either the production
  ; or development versions of the INIs with respect to PHP's default behavior.
  ; Please see the actual settings later in the document for more details as to why
  ; we recommend these changes in PHP's behavior.
  
  ; allow_call_time_pass_reference
  ;   Default Value: On
  ;   Development Value: Off
  ;   Production Value: Off
  
  ; display_errors
  ;   Default Value: On
  ;   Development Value: On
  ;   Production Value: Off
  
  ; display_startup_errors
  ;   Default Value: Off
  ;   Development Value: On
  ;   Production Value: Off
  
  ; error_reporting
  ;   Default Value: E_ALL &amp; ~E_NOTICE
  ;   Development Value: E_ALL | E_STRICT
  ;   Production Value: E_ALL &amp; ~E_DEPRECATED
  
  ; html_errors
  ;   Default Value: On
  ;   Development Value: On
  ;   Production value: Off
  
  ; log_errors
  ;   Default Value: Off
  ;   Development Value: On
  ;   Production Value: On
  
  ; magic_quotes_gpc
  ;   Default Value: On
  ;   Development Value: Off
  ;   Production Value: Off
  
  ; max_input_time
  ;   Default Value: -1 (Unlimited)
  ;   Development Value: 60 (60 seconds)
  ;   Production Value: 60 (60 seconds)
  
  ; output_buffering
  ;   Default Value: Off
  ;   Development Value: 4096
  ;   Production Value: 4096
  
  ; register_argc_argv
  ;   Default Value: On
  ;   Development Value: Off
  ;   Production Value: Off
  
  ; register_long_arrays
  ;   Default Value: On
  ;   Development Value: Off
  ;   Production Value: Off
  
  ; request_order
  ;   Default Value: None
  ;   Development Value: "GP"
  ;   Production Value: "GP"
  
  ; session.bug_compat_42
  ;   Default Value: On
  ;   Development Value: On
  ;   Production Value: Off
  
  ; session.bug_compat_warn
  ;   Default Value: On
  ;   Development Value: On
  ;   Production Value: Off
  
  ; session.gc_divisor
  ;   Default Value: 100
  ;   Development Value: 1000
  ;   Production Value: 1000
  
  ; session.hash_bits_per_character
  ;   Default Value: 4
  ;   Development Value: 5
  ;   Production Value: 5
  
  ; short_open_tag
  ;   Default Value: On
  ;   Development Value: Off
  ;   Production Value: Off
  
  ; track_errors
  ;   Default Value: Off
  ;   Development Value: On
  ;   Production Value: Off
  
  ; url_rewriter.tags
  ;   Default Value: "a=href,area=href,frame=src,form=,fieldset="
  ;   Development Value: "a=href,area=href,frame=src,input=src,form=fakeentry"
  ;   Production Value: "a=href,area=href,frame=src,input=src,form=fakeentry"
  
  ; variables_order
  ;   Default Value: "EGPCS"
  ;   Development Value: "GPCS"
  ;   Production Value: "GPCS"
  
  ;;;;;;;;;;;;;;;;;;;;
  ; php.ini Options  ;
  ;;;;;;;;;;;;;;;;;;;;
  ; Name for user-defined php.ini (.htaccess) files. Default is ".user.ini"
  ;user_ini.filename = ".user.ini"
  
  ; To disable this feature set this option to empty value
  ;user_ini.filename =
  
  ; TTL for user-defined php.ini files (time-to-live) in seconds. Default is 300 seconds (5 minutes)
  ;user_ini.cache_ttl = 300
  
  ;;;;;;;;;;;;;;;;;;;;
  ; Language Options ;
  ;;;;;;;;;;;;;;;;;;;;
  
  ; Enable the PHP scripting language engine under Apache.
  ; http://php.net/engine
  engine = On
  
  ; This directive determines whether or not PHP will recognize code between
  ; &lt;? and ?&gt; tags as PHP source which should be processed as such. It's been
  ; recommended for several years that you not use the short tag "short cut" and
  ; instead to use the full &lt;?php and ?&gt; tag combination. With the wide spread use
  ; of XML and use of these tags by other languages, the server can become easily
  ; confused and end up parsing the wrong code in the wrong context. But because
  ; this short cut has been a feature for such a long time, it's currently still
  ; supported for backwards compatibility, but we recommend you don't use them.
  ; Default Value: On
  ; Development Value: Off
  ; Production Value: Off
  ; http://php.net/short-open-tag
  short_open_tag = Off
  
  ; Allow ASP-style &lt;% %&gt; tags.
  ; http://php.net/asp-tags
  asp_tags = Off
  
  ; The number of significant digits displayed in floating point numbers.
  ; http://php.net/precision
  precision = 14
  
  ; Enforce year 2000 compliance (will cause problems with non-compliant browsers)
  ; http://php.net/y2k-compliance
  y2k_compliance = On
  
  ; Output buffering is a mechanism for controlling how much output data
  ; (excluding headers and cookies) PHP should keep internally before pushing that
  ; data to the client. If your application's output exceeds this setting, PHP
  ; will send that data in chunks of roughly the size you specify.
  ; Turning on this setting and managing its maximum buffer size can yield some
  ; interesting side-effects depending on your application and web server.
  ; You may be able to send headers and cookies after you've already sent output
  ; through print or echo. You also may see performance benefits if your server is
  ; emitting less packets due to buffered output versus PHP streaming the output
  ; as it gets it. On production servers, 4096 bytes is a good setting for performance
  ; reasons.
  ; Note: Output buffering can also be controlled via Output Buffering Control
  ;   functions.
  ; Possible Values:
  ;   On = Enabled and buffer is unlimited. (Use with caution)
  ;   Off = Disabled
  ;   Integer = Enables the buffer and sets its maximum size in bytes.
  ; Note: This directive is hardcoded to Off for the CLI SAPI
  ; Default Value: Off
  ; Development Value: 4096
  ; Production Value: 4096
  ; http://php.net/output-buffering
  output_buffering = Off
  
  ; You can redirect all of the output of your scripts to a function.  For
  ; example, if you set output_handler to "mb_output_handler", character
  ; encoding will be transparently converted to the specified encoding.
  ; Setting any output handler automatically turns on output buffering.
  ; Note: People who wrote portable scripts should not depend on this ini
  ;   directive. Instead, explicitly set the output handler using ob_start().
  ;   Using this ini directive may cause problems unless you know what script
  ;   is doing.
  ; Note: You cannot use both "mb_output_handler" with "ob_iconv_handler"
  ;   and you cannot use both "ob_gzhandler" and "zlib.output_compression".
  ; Note: output_handler must be empty if this is set 'On' !!!!
  ;   Instead you must use zlib.output_handler.
  ; http://php.net/output-handler
  ;output_handler =
  
  ; Transparent output compression using the zlib library
  ; Valid values for this option are 'off', 'on', or a specific buffer size
  ; to be used for compression (default is 4KB)
  ; Note: Resulting chunk size may vary due to nature of compression. PHP
  ;   outputs chunks that are few hundreds bytes each as a result of
  ;   compression. If you prefer a larger chunk size for better
  ;   performance, enable output_buffering in addition.
  ; Note: You need to use zlib.output_handler instead of the standard
  ;   output_handler, or otherwise the output will be corrupted.
  ; http://php.net/zlib.output-compression
  zlib.output_compression = Off
  
  ; http://php.net/zlib.output-compression-level
  ;zlib.output_compression_level = -1
  
  ; You cannot specify additional output handlers if zlib.output_compression
  ; is activated here. This setting does the same as output_handler but in
  ; a different order.
  ; http://php.net/zlib.output-handler
  ;zlib.output_handler =
  
  ; Implicit flush tells PHP to tell the output layer to flush itself
  ; automatically after every output block.  This is equivalent to calling the
  ; PHP function flush() after each and every call to print() or echo() and each
  ; and every HTML block.  Turning this option on has serious performance
  ; implications and is generally recommended for debugging purposes only.
  ; http://php.net/implicit-flush
  ; Note: This directive is hardcoded to On for the CLI SAPI
  implicit_flush = Off
  
  ; The unserialize callback function will be called (with the undefined class'
  ; name as parameter), if the unserializer finds an undefined class
  ; which should be instantiated. A warning appears if the specified function is
  ; not defined, or if the function doesn't include/implement the missing class.
  ; So only set this entry, if you really want to implement such a
  ; callback-function.
  unserialize_callback_func =
  
  ; When floats &amp; doubles are serialized store serialize_precision significant
  ; digits after the floating point. The default value ensures that when floats
  ; are decoded with unserialize, the data will remain the same.
  serialize_precision = 100
  
  ; This directive allows you to enable and disable warnings which PHP will issue
  ; if you pass a value by reference at function call time. Passing values by
  ; reference at function call time is a deprecated feature which will be removed
  ; from PHP at some point in the near future. The acceptable method for passing a
  ; value by reference to a function is by declaring the reference in the functions
  ; definition, not at call time. This directive does not disable this feature, it
  ; only determines whether PHP will warn you about it or not. These warnings
  ; should enabled in development environments only.
  ; Default Value: On (Suppress warnings)
  ; Development Value: Off (Issue warnings)
  ; Production Value: Off (Issue warnings)
  ; http://php.net/allow-call-time-pass-reference
  allow_call_time_pass_reference = On
  
  ; Safe Mode
  ; http://php.net/safe-mode
  safe_mode = Off
  
  ; By default, Safe Mode does a UID compare check when
  ; opening files. If you want to relax this to a GID compare,
  ; then turn on safe_mode_gid.
  ; http://php.net/safe-mode-gid
  safe_mode_gid = Off
  
  ; When safe_mode is on, UID/GID checks are bypassed when
  ; including files from this directory and its subdirectories.
  ; (directory must also be in include_path or full path must
  ; be used when including)
  ; http://php.net/safe-mode-include-dir
  safe_mode_include_dir =
  
  ; When safe_mode is on, only executables located in the safe_mode_exec_dir
  ; will be allowed to be executed via the exec family of functions.
  ; http://php.net/safe-mode-exec-dir
  safe_mode_exec_dir =
  
  ; Setting certain environment variables may be a potential security breach.
  ; This directive contains a comma-delimited list of prefixes.  In Safe Mode,
  ; the user may only alter environment variables whose names begin with the
  ; prefixes supplied here.  By default, users will only be able to set
  ; environment variables that begin with PHP_ (e.g. PHP_FOO=BAR).
  ; Note:  If this directive is empty, PHP will let the user modify ANY
  ;   environment variable!
  ; http://php.net/safe-mode-allowed-env-vars
  safe_mode_allowed_env_vars = PHP_
  
  ; This directive contains a comma-delimited list of environment variables that
  ; the end user won't be able to change using putenv().  These variables will be
  ; protected even if safe_mode_allowed_env_vars is set to allow to change them.
  ; http://php.net/safe-mode-protected-env-vars
  safe_mode_protected_env_vars = LD_LIBRARY_PATH
  
  ; open_basedir, if set, limits all file operations to the defined directory
  ; and below.  This directive makes most sense if used in a per-directory
  ; or per-virtualhost web server configuration file. This directive is
  ; *NOT* affected by whether Safe Mode is turned On or Off.
  ; http://php.net/open-basedir
  ;open_basedir =
  
  ; This directive allows you to disable certain functions for security reasons.
  ; It receives a comma-delimited list of function names. This directive is
  ; *NOT* affected by whether Safe Mode is turned On or Off.
  ; http://php.net/disable-functions
  disable_functions =
  
  ; This directive allows you to disable certain classes for security reasons.
  ; It receives a comma-delimited list of class names. This directive is
  ; *NOT* affected by whether Safe Mode is turned On or Off.
  ; http://php.net/disable-classes
  disable_classes =
  
  ; Colors for Syntax Highlighting mode.  Anything that's acceptable in
  ; &lt;span style="color: ???????"&gt; would work.
  ; http://php.net/syntax-highlighting
  ;highlight.string  = #DD0000
  ;highlight.comment = #FF9900
  ;highlight.keyword = #007700
  ;highlight.bg      = #FFFFFF
  ;highlight.default = #0000BB
  ;highlight.html    = #000000
  
  ; If enabled, the request will be allowed to complete even if the user aborts
  ; the request. Consider enabling it if executing long requests, which may end up
  ; being interrupted by the user or a browser timing out. PHP's default behavior
  ; is to disable this feature.
  ; http://php.net/ignore-user-abort
  ;ignore_user_abort = On
  
  ; Determines the size of the realpath cache to be used by PHP. This value should
  ; be increased on systems where PHP opens many files to reflect the quantity of
  ; the file operations performed.
  ; http://php.net/realpath-cache-size
  ;realpath_cache_size = 16k
  
  ; Duration of time, in seconds for which to cache realpath information for a given
  ; file or directory. For systems with rarely changing files, consider increasing this
  ; value.
  ; http://php.net/realpath-cache-ttl
  ;realpath_cache_ttl = 120
  
  ;;;;;;;;;;;;;;;;;
  ; Miscellaneous ;
  ;;;;;;;;;;;;;;;;;
  
  ; Decides whether PHP may expose the fact that it is installed on the server
  ; (e.g. by adding its signature to the Web server header).  It is no security
  ; threat in any way, but it makes it possible to determine whether you use PHP
  ; on your server or not.
  ; http://php.net/expose-php
  expose_php = On
  
  ;;;;;;;;;;;;;;;;;;;
  ; Resource Limits ;
  ;;;;;;;;;;;;;;;;;;;
  
  ; Maximum execution time of each script, in seconds
  ; http://php.net/max-execution-time
  ; Note: This directive is hardcoded to 0 for the CLI SAPI
  max_execution_time = 60
  
  ; Maximum amount of time each script may spend parsing request data. It's a good
  ; idea to limit this time on productions servers in order to eliminate unexpectedly
  ; long running scripts.
  ; Note: This directive is hardcoded to -1 for the CLI SAPI
  ; Default Value: -1 (Unlimited)
  ; Development Value: 60 (60 seconds)
  ; Production Value: 60 (60 seconds)
  ; http://php.net/max-input-time
  max_input_time = 60
  
  ; Maximum input variable nesting level
  ; http://php.net/max-input-nesting-level
  ;max_input_nesting_level = 64
  
  ; Maximum amount of memory a script may consume (128MB)
  ; http://php.net/memory-limit
  memory_limit = 128M
  
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ; Error handling and logging ;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  
  ; This directive informs PHP of which errors, warnings and notices you would like
  ; it to take action for. The recommended way of setting values for this
  ; directive is through the use of the error level constants and bitwise
  ; operators. The error level constants are below here for convenience as well as
  ; some common settings and their meanings.
  ; By default, PHP is set to take action on all errors, notices and warnings EXCEPT
  ; those related to E_NOTICE and E_STRICT, which together cover best practices and
  ; recommended coding standards in PHP. For performance reasons, this is the
  ; recommend error reporting setting. Your production server shouldn't be wasting
  ; resources complaining about best practices and coding standards. That's what
  ; development servers and development settings are for.
  ; Note: The php.ini-development file has this setting as E_ALL | E_STRICT. This
  ; means it pretty much reports everything which is exactly what you want during
  ; development and early testing.
  ;
  ; Error Level Constants:
  ; E_ALL             - All errors and warnings (includes E_STRICT as of PHP 6.0.0)
  ; E_ERROR           - fatal run-time errors
  ; E_RECOVERABLE_ERROR  - almost fatal run-time errors
  ; E_WARNING         - run-time warnings (non-fatal errors)
  ; E_PARSE           - compile-time parse errors
  ; E_NOTICE          - run-time notices (these are warnings which often result
  ;                     from a bug in your code, but it's possible that it was
  ;                     intentional (e.g., using an uninitialized variable and
  ;                     relying on the fact it's automatically initialized to an
  ;                     empty string)
  ; E_STRICT          - run-time notices, enable to have PHP suggest changes
  ;                     to your code which will ensure the best interoperability
  ;                     and forward compatibility of your code
  ; E_CORE_ERROR      - fatal errors that occur during PHP's initial startup
  ; E_CORE_WARNING    - warnings (non-fatal errors) that occur during PHP's
  ;                     initial startup
  ; E_COMPILE_ERROR   - fatal compile-time errors
  ; E_COMPILE_WARNING - compile-time warnings (non-fatal errors)
  ; E_USER_ERROR      - user-generated error message
  ; E_USER_WARNING    - user-generated warning message
  ; E_USER_NOTICE     - user-generated notice message
  ; E_DEPRECATED      - warn about code that will not work in future versions
  ;                     of PHP
  ; E_USER_DEPRECATED - user-generated deprecation warnings
  ;
  ; Common Values:
  ;   E_ALL &amp; ~E_NOTICE  (Show all errors, except for notices and coding standards warnings.)
  ;   E_ALL &amp; ~E_NOTICE | E_STRICT  (Show all errors, except for notices)
  ;   E_COMPILE_ERROR|E_RECOVERABLE_ERROR|E_ERROR|E_CORE_ERROR  (Show only errors)
  ;   E_ALL | E_STRICT  (Show all errors, warnings and notices including coding standards.)
  ; Default Value: E_ALL &amp; ~E_NOTICE
  ; Development Value: E_ALL | E_STRICT
  ; Production Value: E_ALL &amp; ~E_DEPRECATED
  ; http://php.net/error-reporting
  error_reporting = E_ALL &amp; ~E_NOTICE &amp; ~E_DEPRECATED
  
  ; This directive controls whether or not and where PHP will output errors,
  ; notices and warnings too. Error output is very useful during development, but
  ; it could be very dangerous in production environments. Depending on the code
  ; which is triggering the error, sensitive information could potentially leak
  ; out of your application such as database usernames and passwords or worse.
  ; It's recommended that errors be logged on production servers rather than
  ; having the errors sent to STDOUT.
  ; Possible Values:
  ;   Off = Do not display any errors
  ;   stderr = Display errors to STDERR (affects only CGI/CLI binaries!)
  ;   On or stdout = Display errors to STDOUT
  ; Default Value: On
  ; Development Value: On
  ; Production Value: Off
  ; http://php.net/display-errors
  display_errors = On
  
  ; The display of errors which occur during PHP's startup sequence are handled
  ; separately from display_errors. PHP's default behavior is to suppress those
  ; errors from clients. Turning the display of startup errors on can be useful in
  ; debugging configuration problems. But, it's strongly recommended that you
  ; leave this setting off on production servers.
  ; Default Value: Off
  ; Development Value: On
  ; Production Value: Off
  ; http://php.net/display-startup-errors
  display_startup_errors = On
  
  ; Besides displaying errors, PHP can also log errors to locations such as a
  ; server-specific log, STDERR, or a location specified by the error_log
  ; directive found below. While errors should not be displayed on productions
  ; servers they should still be monitored and logging is a great way to do that.
  ; Default Value: Off
  ; Development Value: On
  ; Production Value: On
  ; http://php.net/log-errors
  log_errors = Off
  
  ; Set maximum length of log_errors. In error_log information about the source is
  ; added. The default is 1024 and 0 allows to not apply any maximum length at all.
  ; http://php.net/log-errors-max-len
  log_errors_max_len = 1024
  
  ; Do not log repeated messages. Repeated errors must occur in same file on same
  ; line unless ignore_repeated_source is set true.
  ; http://php.net/ignore-repeated-errors
  ignore_repeated_errors = Off
  
  ; Ignore source of message when ignoring repeated messages. When this setting
  ; is On you will not log errors with repeated messages from different files or
  ; source lines.
  ; http://php.net/ignore-repeated-source
  ignore_repeated_source = Off
  
  ; If this parameter is set to Off, then memory leaks will not be shown (on
  ; stdout or in the log). This has only effect in a debug compile, and if
  ; error reporting includes E_WARNING in the allowed list
  ; http://php.net/report-memleaks
  report_memleaks = On
  
  ; This setting is on by default.
  ;report_zend_debug = 0
  
  ; Store the last error/warning message in $php_errormsg (boolean). Setting this value
  ; to On can assist in debugging and is appropriate for development servers. It should
  ; however be disabled on production servers.
  ; Default Value: Off
  ; Development Value: On
  ; Production Value: Off
  ; http://php.net/track-errors
  track_errors = Off
  
  ; Turn off normal error reporting and emit XML-RPC error XML
  ; http://php.net/xmlrpc-errors
  ;xmlrpc_errors = 0
  
  ; An XML-RPC faultCode
  ;xmlrpc_error_number = 0
  
  ; When PHP displays or logs an error, it has the capability of inserting html
  ; links to documentation related to that error. This directive controls whether
  ; those HTML links appear in error messages or not. For performance and security
  ; reasons, it's recommended you disable this on production servers.
  ; Note: This directive is hardcoded to Off for the CLI SAPI
  ; Default Value: On
  ; Development Value: On
  ; Production value: Off
  ; http://php.net/html-errors
  html_errors = On
  
  ; If html_errors is set On PHP produces clickable error messages that direct
  ; to a page describing the error or function causing the error in detail.
  ; You can download a copy of the PHP manual from http://php.net/docs
  ; and change docref_root to the base URL of your local copy including the
  ; leading '/'. You must also specify the file extension being used including
  ; the dot. PHP's default behavior is to leave these settings empty.
  ; Note: Never use this feature for production boxes.
  ; http://php.net/docref-root
  ; Examples
  ;docref_root = "/phpmanual/"
  
  ; http://php.net/docref-ext
  ;docref_ext = .html
  
  ; String to output before an error message. PHP's default behavior is to leave
  ; this setting blank.
  ; http://php.net/error-prepend-string
  ; Example:
  ;error_prepend_string = "&lt;font color=#ff0000&gt;"
  
  ; String to output after an error message. PHP's default behavior is to leave
  ; this setting blank.
  ; http://php.net/error-append-string
  ; Example:
  ;error_append_string = "&lt;/font&gt;"
  
  ; Log errors to specified file. PHP's default behavior is to leave this value
  ; empty.
  ; http://php.net/error-log
  ; Example:
  ;error_log = php_errors.log
  ; Log errors to syslog (Event Log on NT, not valid in Windows 95).
  ;error_log = syslog
  ;error_log = "C:\xampp\apache\logs\php_error.log"
  
  ;;;;;;;;;;;;;;;;;
  ; Data Handling ;
  ;;;;;;;;;;;;;;;;;
  
  ; Note - track_vars is ALWAYS enabled
  
  ; The separator used in PHP generated URLs to separate arguments.
  ; PHP's default setting is "&amp;".
  ; http://php.net/arg-separator.output
  ; Example:
  arg_separator.output = "&amp;amp;"
  
  ; List of separator(s) used by PHP to parse input URLs into variables.
  ; PHP's default setting is "&amp;
  </code></pre>