2008-02-06 04:27:49 +00:00
|
|
|
/**************************************************************************
|
|
|
|
*
|
|
|
|
* Copyright 2008 Tungsten Graphics, Inc., Cedar Park, Texas.
|
|
|
|
* All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
* the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
|
|
* of the Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
|
|
|
|
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
|
|
|
|
* IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
|
|
|
|
* ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
|
|
|
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
|
|
|
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
2008-04-25 10:19:51 +01:00
|
|
|
#include "pipe/p_config.h"
|
|
|
|
|
2008-02-06 04:27:49 +00:00
|
|
|
#include <stdarg.h>
|
|
|
|
|
2008-04-25 10:19:51 +01:00
|
|
|
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
|
2008-02-06 04:27:49 +00:00
|
|
|
#include <windows.h>
|
|
|
|
#include <winddi.h>
|
|
|
|
#else
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include "pipe/p_compiler.h"
|
2008-03-12 15:01:18 +00:00
|
|
|
#include "pipe/p_util.h"
|
|
|
|
#include "pipe/p_debug.h"
|
2008-04-29 20:33:37 +01:00
|
|
|
#include "pipe/p_format.h"
|
2008-04-14 15:55:36 +01:00
|
|
|
#include "util/u_string.h"
|
2008-02-06 04:27:49 +00:00
|
|
|
|
|
|
|
|
2008-04-25 10:19:51 +01:00
|
|
|
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
|
2008-03-05 10:38:21 +00:00
|
|
|
static INLINE void
|
2008-04-02 02:21:24 +01:00
|
|
|
_EngDebugPrint(const char *format, ...)
|
2008-03-05 10:38:21 +00:00
|
|
|
{
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, format);
|
|
|
|
EngDebugPrint("", (PCHAR)format, ap);
|
|
|
|
va_end(ap);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2008-03-24 20:18:59 +00:00
|
|
|
void _debug_vprintf(const char *format, va_list ap)
|
2008-02-06 04:27:49 +00:00
|
|
|
{
|
2008-04-25 10:19:51 +01:00
|
|
|
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
|
2008-03-10 13:04:13 +00:00
|
|
|
#ifndef WINCE
|
2008-03-05 10:38:21 +00:00
|
|
|
/* EngDebugPrint does not handle float point arguments, so we need to use
|
2008-04-15 10:11:47 +01:00
|
|
|
* our own vsnprintf implementation. It is also very slow, so buffer until
|
|
|
|
* we find a newline. */
|
|
|
|
static char buf[512 + 1] = {'\0'};
|
|
|
|
size_t len = strlen(buf);
|
|
|
|
int ret = util_vsnprintf(buf + len, sizeof(buf) - len, format, ap);
|
2008-05-07 11:39:34 +01:00
|
|
|
if(ret > (int)(sizeof(buf) - len - 1) || util_strchr(buf + len, '\n')) {
|
2008-04-15 10:11:47 +01:00
|
|
|
_EngDebugPrint("%s", buf);
|
|
|
|
buf[0] = '\0';
|
|
|
|
}
|
2008-03-10 13:04:13 +00:00
|
|
|
#else
|
|
|
|
/* TODO: Implement debug print for WINCE */
|
|
|
|
#endif
|
2008-02-06 04:27:49 +00:00
|
|
|
#else
|
|
|
|
vfprintf(stderr, format, ap);
|
|
|
|
#endif
|
2008-02-06 16:07:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-24 20:18:59 +00:00
|
|
|
#ifdef DEBUG
|
2008-03-20 13:10:32 +00:00
|
|
|
void debug_print_blob( const char *name,
|
|
|
|
const void *blob,
|
|
|
|
unsigned size )
|
|
|
|
{
|
|
|
|
const unsigned *ublob = (const unsigned *)blob;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
debug_printf("%s (%d dwords%s)\n", name, size/4,
|
|
|
|
size%4 ? "... plus a few bytes" : "");
|
|
|
|
|
|
|
|
for (i = 0; i < size/4; i++) {
|
|
|
|
debug_printf("%d:\t%08x\n", i, ublob[i]);
|
|
|
|
}
|
|
|
|
}
|
2008-03-24 20:18:59 +00:00
|
|
|
#endif
|
2008-03-20 13:10:32 +00:00
|
|
|
|
|
|
|
|
2008-03-24 20:18:59 +00:00
|
|
|
void _debug_break(void)
|
2008-02-06 04:27:49 +00:00
|
|
|
{
|
2008-03-10 21:18:00 +00:00
|
|
|
#if (defined(__i386__) || defined(__386__)) && defined(__GNUC__)
|
|
|
|
__asm("int3");
|
|
|
|
#elif (defined(__i386__) || defined(__386__)) && defined(__MSC__)
|
2008-03-10 13:04:13 +00:00
|
|
|
_asm {int 3};
|
2008-04-30 16:59:12 +01:00
|
|
|
#elif defined(PIPE_SUBSYSTEM_WINDOWS_DISPLAY)
|
2008-03-10 21:18:00 +00:00
|
|
|
EngDebugBreak();
|
2008-02-06 04:27:49 +00:00
|
|
|
#else
|
|
|
|
abort();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2008-03-24 22:30:33 +00:00
|
|
|
|
2008-04-25 10:19:51 +01:00
|
|
|
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
|
2008-03-24 22:30:33 +00:00
|
|
|
static const char *
|
|
|
|
find(const char *start, const char *end, char c)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
for(p = start; !end || p != end; ++p) {
|
|
|
|
if(*p == c)
|
|
|
|
return p;
|
|
|
|
if(*p < 32)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
compare(const char *start, const char *end, const char *s)
|
|
|
|
{
|
|
|
|
const char *p, *q;
|
|
|
|
for(p = start, q = s; p != end && *q != '\0'; ++p, ++q) {
|
|
|
|
if(*p != *q)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
return p == end && *q == '\0';
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
copy(char *dst, const char *start, const char *end, size_t n)
|
|
|
|
{
|
|
|
|
const char *p;
|
|
|
|
char *q;
|
|
|
|
for(p = start, q = dst, n = n - 1; p != end && n; ++p, ++q, --n)
|
|
|
|
*q = *p;
|
|
|
|
*q = '\0';
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
debug_get_option(const char *name, const char *dfault)
|
|
|
|
{
|
|
|
|
const char *result;
|
2008-04-25 10:19:51 +01:00
|
|
|
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
|
2008-03-24 22:30:33 +00:00
|
|
|
ULONG_PTR iFile = 0;
|
|
|
|
const void *pMap = NULL;
|
|
|
|
const char *sol, *eol, *sep;
|
|
|
|
static char output[1024];
|
|
|
|
|
2008-03-25 11:37:24 +00:00
|
|
|
result = dfault;
|
|
|
|
/* XXX: this creates the file if it does not exists, so it must either be
|
|
|
|
* disabled on release versions, or put in a less conspicuous place.
|
|
|
|
*/
|
2008-03-24 22:30:33 +00:00
|
|
|
pMap = EngMapFile(L"\\??\\c:\\gallium.cfg", 0, &iFile);
|
2008-03-25 11:37:24 +00:00
|
|
|
if(pMap) {
|
2008-03-24 22:30:33 +00:00
|
|
|
sol = (const char *)pMap;
|
|
|
|
while(1) {
|
|
|
|
/* TODO: handle LF line endings */
|
|
|
|
eol = find(sol, NULL, '\r');
|
|
|
|
if(!eol || eol == sol)
|
|
|
|
break;
|
|
|
|
sep = find(sol, eol, '=');
|
|
|
|
if(!sep)
|
|
|
|
break;
|
|
|
|
if(compare(sol, sep, name)) {
|
|
|
|
copy(output, sep + 1, eol, sizeof(output));
|
|
|
|
result = output;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
sol = eol + 2;
|
|
|
|
}
|
|
|
|
EngUnmapFile(iFile);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
|
|
|
|
result = getenv(name);
|
|
|
|
if(!result)
|
|
|
|
result = dfault;
|
|
|
|
#endif
|
|
|
|
|
2008-03-25 11:37:24 +00:00
|
|
|
debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? result : "(null)");
|
2008-03-24 22:30:33 +00:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
boolean
|
|
|
|
debug_get_bool_option(const char *name, boolean dfault)
|
|
|
|
{
|
|
|
|
const char *str = debug_get_option(name, NULL);
|
|
|
|
boolean result;
|
|
|
|
|
|
|
|
if(str == NULL)
|
|
|
|
result = dfault;
|
2008-05-07 11:39:34 +01:00
|
|
|
else if(!util_strcmp(str, "n"))
|
2008-04-16 14:32:10 +01:00
|
|
|
result = FALSE;
|
2008-05-07 11:39:34 +01:00
|
|
|
else if(!util_strcmp(str, "no"))
|
2008-03-24 22:30:33 +00:00
|
|
|
result = FALSE;
|
2008-05-07 11:39:34 +01:00
|
|
|
else if(!util_strcmp(str, "0"))
|
2008-03-24 22:30:33 +00:00
|
|
|
result = FALSE;
|
2008-05-07 11:39:34 +01:00
|
|
|
else if(!util_strcmp(str, "f"))
|
2008-03-24 22:30:33 +00:00
|
|
|
result = FALSE;
|
2008-05-07 11:39:34 +01:00
|
|
|
else if(!util_strcmp(str, "false"))
|
2008-03-24 22:30:33 +00:00
|
|
|
result = FALSE;
|
|
|
|
else
|
|
|
|
result = TRUE;
|
|
|
|
|
|
|
|
debug_printf("%s: %s = %s\n", __FUNCTION__, name, result ? "TRUE" : "FALSE");
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
long
|
|
|
|
debug_get_num_option(const char *name, long dfault)
|
|
|
|
{
|
|
|
|
/* FIXME */
|
|
|
|
return dfault;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
unsigned long
|
|
|
|
debug_get_flags_option(const char *name,
|
|
|
|
const struct debug_named_value *flags,
|
|
|
|
unsigned long dfault)
|
|
|
|
{
|
|
|
|
unsigned long result;
|
|
|
|
const char *str;
|
|
|
|
|
|
|
|
str = debug_get_option(name, NULL);
|
|
|
|
if(!str)
|
|
|
|
result = dfault;
|
|
|
|
else {
|
|
|
|
result = 0;
|
|
|
|
while( flags->name ) {
|
2008-05-07 11:39:34 +01:00
|
|
|
if (!util_strcmp(str, "all") || util_strstr(str, flags->name ))
|
2008-03-24 22:30:33 +00:00
|
|
|
result |= flags->value;
|
|
|
|
++flags;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
debug_printf("%s: %s = 0x%lx\n", __FUNCTION__, name, result);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-24 20:18:59 +00:00
|
|
|
void _debug_assert_fail(const char *expr,
|
|
|
|
const char *file,
|
|
|
|
unsigned line,
|
|
|
|
const char *function)
|
2008-02-06 04:27:49 +00:00
|
|
|
{
|
2008-03-24 20:18:59 +00:00
|
|
|
_debug_printf("%s:%u:%s: Assertion `%s' failed.\n", file, line, function, expr);
|
2008-04-16 14:32:10 +01:00
|
|
|
if (debug_get_bool_option("GALLIUM_ABORT_ON_ASSERT", TRUE))
|
2008-03-12 15:01:18 +00:00
|
|
|
debug_break();
|
2008-04-16 14:32:10 +01:00
|
|
|
else
|
2008-03-24 20:18:59 +00:00
|
|
|
_debug_printf("continuing...\n");
|
2008-02-06 04:27:49 +00:00
|
|
|
}
|
2008-03-11 12:03:11 +00:00
|
|
|
|
|
|
|
|
2008-03-19 16:41:07 +00:00
|
|
|
const char *
|
|
|
|
debug_dump_enum(const struct debug_named_value *names,
|
|
|
|
unsigned long value)
|
|
|
|
{
|
|
|
|
static char rest[256];
|
|
|
|
|
|
|
|
while(names->name) {
|
|
|
|
if(names->value == value)
|
|
|
|
return names->name;
|
|
|
|
++names;
|
|
|
|
}
|
|
|
|
|
2008-04-14 15:55:36 +01:00
|
|
|
util_snprintf(rest, sizeof(rest), "0x%08lx", value);
|
2008-03-19 16:41:07 +00:00
|
|
|
return rest;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const char *
|
|
|
|
debug_dump_flags(const struct debug_named_value *names,
|
|
|
|
unsigned long value)
|
|
|
|
{
|
|
|
|
static char output[4096];
|
|
|
|
static char rest[256];
|
|
|
|
int first = 1;
|
|
|
|
|
|
|
|
output[0] = '\0';
|
|
|
|
|
|
|
|
while(names->name) {
|
|
|
|
if((names->value & value) == names->value) {
|
|
|
|
if (!first)
|
2008-05-07 11:39:34 +01:00
|
|
|
util_strncat(output, "|", sizeof(output));
|
2008-03-19 16:41:07 +00:00
|
|
|
else
|
|
|
|
first = 0;
|
2008-05-07 11:39:34 +01:00
|
|
|
util_strncat(output, names->name, sizeof(output));
|
2008-03-19 16:41:07 +00:00
|
|
|
value &= ~names->value;
|
|
|
|
}
|
|
|
|
++names;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (value) {
|
|
|
|
if (!first)
|
2008-05-07 11:39:34 +01:00
|
|
|
util_strncat(output, "|", sizeof(output));
|
2008-03-19 16:41:07 +00:00
|
|
|
else
|
|
|
|
first = 0;
|
|
|
|
|
2008-04-14 15:55:36 +01:00
|
|
|
util_snprintf(rest, sizeof(rest), "0x%08lx", value);
|
2008-05-07 11:39:34 +01:00
|
|
|
util_strncat(output, rest, sizeof(output));
|
2008-03-19 16:41:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if(first)
|
|
|
|
return "0";
|
|
|
|
|
|
|
|
return output;
|
|
|
|
}
|
2008-03-20 13:10:32 +00:00
|
|
|
|
|
|
|
|
2008-04-29 20:33:37 +01:00
|
|
|
char *pf_sprint_name( char *str, enum pipe_format format )
|
|
|
|
{
|
|
|
|
strcpy( str, "PIPE_FORMAT_" );
|
|
|
|
switch (pf_layout( format )) {
|
|
|
|
case PIPE_FORMAT_LAYOUT_RGBAZS:
|
|
|
|
{
|
|
|
|
pipe_format_rgbazs_t rgbazs = (pipe_format_rgbazs_t) format;
|
|
|
|
uint i;
|
|
|
|
uint scale = 1 << (pf_exp8( rgbazs ) * 3);
|
|
|
|
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
uint size = pf_size_xyzw( rgbazs, i );
|
|
|
|
|
|
|
|
if (size == 0) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
switch (pf_swizzle_xyzw( rgbazs, i )) {
|
|
|
|
case PIPE_FORMAT_COMP_R:
|
|
|
|
strcat( str, "R" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_G:
|
|
|
|
strcat( str, "G" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_B:
|
|
|
|
strcat( str, "B" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_A:
|
|
|
|
strcat( str, "A" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_0:
|
|
|
|
strcat( str, "0" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_1:
|
|
|
|
strcat( str, "1" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_Z:
|
|
|
|
strcat( str, "Z" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_COMP_S:
|
|
|
|
strcat( str, "S" );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
util_snprintf( &str[strlen( str )], 32, "%u", size * scale );
|
|
|
|
}
|
|
|
|
if (i != 0) {
|
|
|
|
strcat( str, "_" );
|
|
|
|
}
|
|
|
|
switch (pf_type( rgbazs )) {
|
|
|
|
case PIPE_FORMAT_TYPE_UNKNOWN:
|
|
|
|
strcat( str, "NONE" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_TYPE_FLOAT:
|
|
|
|
strcat( str, "FLOAT" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_TYPE_UNORM:
|
|
|
|
strcat( str, "UNORM" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_TYPE_SNORM:
|
|
|
|
strcat( str, "SNORM" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_TYPE_USCALED:
|
|
|
|
strcat( str, "USCALED" );
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_TYPE_SSCALED:
|
|
|
|
strcat( str, "SSCALED" );
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case PIPE_FORMAT_LAYOUT_YCBCR:
|
|
|
|
{
|
|
|
|
pipe_format_ycbcr_t ycbcr = (pipe_format_ycbcr_t) format;
|
|
|
|
|
|
|
|
strcat( str, "YCBCR" );
|
|
|
|
if (pf_rev( ycbcr )) {
|
|
|
|
strcat( str, "_REV" );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-04-30 19:43:19 +01:00
|
|
|
#ifdef DEBUG
|
2008-04-29 22:21:10 +01:00
|
|
|
void debug_print_format(const char *msg, unsigned fmt )
|
2008-04-29 20:33:37 +01:00
|
|
|
{
|
|
|
|
char fmtstr[80];
|
|
|
|
|
2008-04-29 22:21:10 +01:00
|
|
|
pf_sprint_name(fmtstr, (enum pipe_format)fmt);
|
2008-04-29 20:33:37 +01:00
|
|
|
|
|
|
|
debug_printf("%s: %s\n", msg, fmtstr);
|
|
|
|
}
|
2008-05-01 02:20:31 +01:00
|
|
|
#endif
|
2008-05-06 18:51:49 +01:00
|
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
void debug_dump_image(const char *prefix,
|
|
|
|
unsigned format, unsigned cpp,
|
|
|
|
unsigned width, unsigned height,
|
|
|
|
unsigned pitch,
|
|
|
|
const void *data)
|
|
|
|
{
|
|
|
|
#ifdef PIPE_SUBSYSTEM_WINDOWS_DISPLAY
|
|
|
|
static unsigned no = 0;
|
|
|
|
char filename[256];
|
|
|
|
WCHAR wfilename[sizeof(filename)];
|
|
|
|
ULONG_PTR iFile = 0;
|
|
|
|
struct {
|
|
|
|
unsigned format;
|
|
|
|
unsigned cpp;
|
|
|
|
unsigned width;
|
|
|
|
unsigned height;
|
|
|
|
} header;
|
|
|
|
unsigned char *pMap = NULL;
|
|
|
|
unsigned i;
|
|
|
|
|
|
|
|
util_snprintf(filename, sizeof(filename), "\\??\\c:\\%03u%s.raw", ++no, prefix);
|
|
|
|
for(i = 0; i < sizeof(filename); ++i)
|
|
|
|
wfilename[i] = (WCHAR)filename[i];
|
|
|
|
|
|
|
|
pMap = (unsigned char *)EngMapFile(wfilename, sizeof(header) + cpp*width*height, &iFile);
|
|
|
|
if(!pMap)
|
|
|
|
return;
|
|
|
|
|
|
|
|
header.format = format;
|
|
|
|
header.cpp = cpp;
|
|
|
|
header.width = width;
|
|
|
|
header.height = height;
|
|
|
|
memcpy(pMap, &header, sizeof(header));
|
|
|
|
pMap += sizeof(header);
|
|
|
|
|
|
|
|
for(i = 0; i < height; ++i) {
|
|
|
|
memcpy(pMap, (unsigned char *)data + cpp*pitch*i, cpp*width);
|
|
|
|
pMap += cpp*width;
|
|
|
|
}
|
|
|
|
|
|
|
|
EngUnmapFile(iFile);
|
|
|
|
#endif
|
|
|
|
}
|
2008-05-07 11:39:34 +01:00
|
|
|
#endif
|