code:
/****************************************************************************
Copyright (c) 2010 cocos2d-x.org

http://www.cocos2d-x.org

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, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS 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.
****************************************************************************/

#include "CCCommon.h"
#include <FApp.h>
#include <FBase.h>
#include <FUi.h>

using namespace Osp::App;
using namespace Osp::Base;
using namespace Osp::Ui;
using namespace Osp::Ui::Controls;

extern "C" {

#ifndef CC_BADA_2_0
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>
#include <limits.h>
#include <malloc.h>
#include <errno.h>

#undef errno

static int errno = 0;

#define	_U	01
#define	_L	02
#define	_N	04
#define	_S	010
#define _P	020
#define _C	040
#define _X	0100
#define	_B	0200

#define _CTYPE_DATA_0_127 \
	_C,	_C,	_C,	_C,	_C,	_C,	_C,	_C, \
	_C,	_C|_S, _C|_S, _C|_S,	_C|_S,	_C|_S,	_C,	_C, \
	_C,	_C,	_C,	_C,	_C,	_C,	_C,	_C, \
	_C,	_C,	_C,	_C,	_C,	_C,	_C,	_C, \
	_S|_B,	_P,	_P,	_P,	_P,	_P,	_P,	_P, \
	_P,	_P,	_P,	_P,	_P,	_P,	_P,	_P, \
	_N,	_N,	_N,	_N,	_N,	_N,	_N,	_N, \
	_N,	_N,	_P,	_P,	_P,	_P,	_P,	_P, \
	_P,	_U|_X,	_U|_X,	_U|_X,	_U|_X,	_U|_X,	_U|_X,	_U, \
	_U,	_U,	_U,	_U,	_U,	_U,	_U,	_U, \
	_U,	_U,	_U,	_U,	_U,	_U,	_U,	_U, \
	_U,	_U,	_U,	_P,	_P,	_P,	_P,	_P, \
	_P,	_L|_X,	_L|_X,	_L|_X,	_L|_X,	_L|_X,	_L|_X,	_L, \
	_L,	_L,	_L,	_L,	_L,	_L,	_L,	_L, \
	_L,	_L,	_L,	_L,	_L,	_L,	_L,	_L, \
	_L,	_L,	_L,	_P,	_P,	_P,	_P,	_C

#define _CTYPE_DATA_128_255 \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0, \
	0,	0,	0,	0,	0,	0,	0,	0

static char _ctype_b[128 + 256] = {
    _CTYPE_DATA_128_255,
    _CTYPE_DATA_0_127,
    _CTYPE_DATA_128_255
};

//char *__ctype_ptr__ = (char *) _ctype_b + 127;

int printf(const char* format, ...)
{
	char szBuf[cocos2d::kMaxLogLen] = {0};
	va_list args;
	va_start(args, format);
	int n = vsnprintf(szBuf, cocos2d::kMaxLogLen, format, args);
	va_end(args);
	AppLog(szBuf);
	return n;
}

int sprintf(char* buf, const char *format, ...)
{
	va_list ap;

	va_start(ap, format);

	char szBuf[cocos2d::kMaxLogLen] = {0};

	int n = vsnprintf(szBuf, cocos2d::kMaxLogLen, format, ap);
	va_end(ap) ;

	strcpy(buf, szBuf);

//	AppLog(buf);

	return n;
}

/* The internal entry points for `strtoX' take an extra flag argument
   saying whether or not to parse locale-dependent number grouping.  */

static double __strtod_internal  (const char *__nptr,char **__endptr, int __group);
static float __strtof_internal (const char *__nptr, char **__endptr,int __group);
static long double __strtold_internal  (const char *__nptr,char **__endptr, int __group);
static long int __strtol_internal (const char *__nptr, char **__endptr,	int __base, int __group);
static unsigned long int __strtoul_internal  (const char *__nptr,  char **__endptr, int __base, int __group);

#ifdef	__GNUC__
#define	HAVE_LONGLONG
#define	MLONGLONG	long long
#else
#define	MLONGLONG	long
#endif

/* Those are flags in the conversion format. */
# define MLONG		0x001	/* l: long or double */
# define MLONGDBL	0x002	/* L: long long or long double */
# define MSHORT		0x004	/* h: short */
# define MSUPPRESS	0x008	/* *: suppress assignment */
# define MPOINTER	0x010	/* weird %p pointer (`fake hex') */
# define MNOSKIP		0x020	/* do not skip blanks */
# define MWIDTH		0x040	/* width was given */
# define MGROUP		0x080	/* ': group numbers */
# define MMALLOC		0x100	/* a: malloc strings */

#define TYPEMOD	(MLONG|MLONGDBL|MSHORT)
#define _IOREAD         0x0001

typedef struct _myiobuf {
	char *_ptr;
	int   _cnt;
	char *_base;
	int   _flag;
	int   _file;
	int   _charbuf;
	int   _bufsiz;
	char *_tmpfname;
}MYFILE;

static int my_getc(MYFILE *fp)
{
	int c = -1;
	// check for invalid stream

// 	if ( !__validfp (fp) ) {
// 		__set_errno(EINVAL);
// 		return EOF;
// 	}
	// check for read access on stream

// 	if ( !OPEN4READING(fp) ) {
// 		__set_errno(EINVAL);
// 		return -1;
// 	}

	if(fp->_cnt > 0) {
		fp->_cnt--;
		c =  (int)*fp->_ptr++;
	}
// 	else {
// 		c =  _filbuf(fp);
// 	}
	return c;
}

static int sys_ungetc(int c, MYFILE *f)
{

// 	if (!__validfp (f) || !OPEN4READING(f)) {
// 		__set_errno (EINVAL);
// 		return EOF;
// 	}

	if (c == EOF )
		return EOF;

	if ( f->_ptr == NULL || f->_base == NULL)
		return EOF;

	if (f->_ptr == f->_base)
	{
		if (f->_cnt == 0)
			f->_ptr++;
		else
			return EOF;
	}

	f->_cnt++;
	f->_ptr--;
	if(*f->_ptr != c)
	{
//		f->_flag |= _IOUNGETC;
		*f->_ptr = c;
	}
	return c;
}

#define my_ungetc(c, s)	((void) (c != EOF && --read_in), sys_ungetc (c, s))
#define inchar()	((c = my_getc (s)), (void) (c != EOF && ++read_in), c)
#define encode_error()	do {						      \
			  funlockfile (s);				      \
			  /*__set_errno (EILSEQ);*/				      \
			  return done;					      \
			} while (0)
#define conv_error()	do {						      \
			  funlockfile (s);				      \
			  return done;					      \
			} while (0)
#define input_error()	do {						      \
			  funlockfile (s);				      \
			  return done ? 0 : EOF;				      \
			} while (0)
#define memory_error()	do {						      \
			  funlockfile (s);				      \
			  __set_errno (ENOMEM);				      \
			  return EOF;					      \
			} while (0)
#define ARGCHECK(s, format)						      \
  do									      \
    {									      \
      /* Check file argument for consistence.  */			      \
      if (!__validfp (s) || !s->__mode.__read)				      \
	{								      \
	  __set_errno (EBADF);						      \
	  return EOF;							      \
	}								      \
      else if (format == NULL)						      \
	{								      \
	  __set_errno (EINVAL);						      \
	  return EOF;							      \
	}								      \
    } while (0)

#define flockfile(S) /* nothing */
#define funlockfile(S) /* nothing */

static char *wp = NULL;		/* Workspace.  */
static size_t wpmax = 0;		/* Maximal size of workspace.  */
static size_t wpsize = 0;		/* Currently used bytes in workspace.  */

static void ADDW(int Ch)							    								        \
{
      if (wpsize == wpmax)
  	{
	  char *old = wp;
	  wpmax = UCHAR_MAX > 2 * wpmax ? UCHAR_MAX : 2 * wpmax;
	  wp = (char *) malloc (wpmax);
	  if (old != NULL) {
	    memcpy (wp, old, wpsize);
	    free(old);
	  }
	}
      wp[wpsize++] = (Ch);

}

static int iswspace(wint_t c)
{
#ifdef _MB_CAPABLE
  c = _jp2uc (c);
  /** Based on Unicode 5.2.  Control chars 09-0D, plus all characters
     from general category "Zs", which are not marked as decomposition
     type "noBreak". */
  return ((c >= 0x0009 && c <= 0x000d) || c == 0x0020 ||
	  c == 0x1680 || c == 0x180e ||
	  (c >= 0x2000 && c <= 0x2006) ||
	  (c >= 0x2008 && c <= 0x200a) ||
	  c == 0x2028 || c == 0x2029 ||
	  c == 0x205f || c == 0x3000);
#else
  return (c < 0x100 ? isspace (c) : 0);
#endif /** _MB_CAPABLE */
}

static int __vfscanf (MYFILE *s, const char *format, va_list argptr)
{
  va_list arg;
  register const char *f = format;
  register unsigned char fc;	/* Current character of the format.  */
  register size_t done = 0;	/* Assignments done.  */
  register size_t read_in = 0;	/* Chars read in.  */
  register int c = 0;		/* Last char read.  */
  register int width;		/* Maximum field width.  */
  register int flags;		/* Modifiers for current format element.  */

  /* Status for reading F-P nums.  */
  char got_dot, got_e, negative;
  /* If a [...] is a [^...].  */
  char not_in;
  /* Base for integral numbers.  */
  int base;
  /* Signedness for integral numbers.  */
  int number_signed;
  /* Decimal point character.  */
  wchar_t decimal = '.';
  /* The thousands character of the current locale.  */
  wchar_t thousands = ',';
  /* Integral holding variables.  */
  union
    {
      long long int q;
      unsigned long long int uq;
      long int l;
      unsigned long int ul;
    } num;
  /* Character-buffer pointer.  */
  char *str = NULL;
  wchar_t *wstr = NULL;
  char **strptr = NULL;
  size_t strsize = 0;
  /* We must not react on white spaces immediately because they can
     possibly be matched even if in the input stream no character is
     available anymore.  */
  int skip_space = 0;
  /* Workspace.  */
  char *tw;			/* Temporary pointer.  */

#ifdef __va_copy
  __va_copy (arg, argptr);
#else
  arg = (va_list) argptr;
#endif

  /* Run through the format string.  */
  while (*f != '\0')
    {
      unsigned int argpos;
      /* Extract the next argument, which is of type TYPE.
	 For a %N$... spec, this is the Nth argument from the beginning;
	 otherwise it is the next argument after the state now in ARG.  */
#define ARG(type)	va_arg(argptr,type)

      if (!isascii (*f))
	{
	  /* Non-ASCII, may be a multibyte.  */
	 // int len = mblen (f, strlen (f));
	int len =1;
	  if (len > 0)
	    {
	      do
		{
		  c = inchar ();
		  if (c == EOF)
		    input_error ();
		  else if (c != *f++)
		    {
		      my_ungetc (c, s);
		      conv_error ();
		    }
		}
	      while (--len > 0);
	      continue;
	    }
	}

      fc = *f++;
      if (fc != '%')
	{
	  /* Remember to skip spaces.  */
	  if (isspace (fc))
	    {
	      skip_space = 1;
	      continue;
	    }

	  /* Read a character.  */
	  c = inchar ();

	  /* Characters other than format specs must just match.  */
	  if (c == EOF)
	    input_error ();

	  /* We saw white space char as the last character in the format
	     string.  Now it's time to skip all leading white space.  */
	  if (skip_space)
	    {
	      while (isspace (c))
		if (inchar () == EOF && errno == EINTR)
		  conv_error ();
	      skip_space = 0;
	    }

	  if (c != fc)
	    {
	      my_ungetc (c, s);
	      conv_error ();
	    }

	  continue;
	}

      /* This is the start of the conversion string. */
      flags = 0;

      /* Initialize state of modifiers.  */
      argpos = 0;

      /* Prepare temporary buffer.  */
      wpsize = 0;

      /* Check for a positional parameter specification.  */
      if (isdigit (*f))
	{
	  argpos = *f++ - '0';
	  while (isdigit (*f))
	    argpos = argpos * 10 + (*f++ - '0');
	  if (*f == '$')
	    ++f;
	  else
	    {
	      /* Oops; that was actually the field width.  */
	      width = argpos;
	      flags |= MWIDTH;
	      argpos = 0;
	      goto got_width;
	    }
	}

      /* Check for the assignment-suppressing and the number grouping flag.  */
      while (*f == '*' || *f == '\'')
	switch (*f++)
	  {
	  case '*':
	    flags |= MSUPPRESS;
	    break;
	  case '\'':
	    flags |= MGROUP;
	    break;
	  }

      /* We have seen width. */
      if (isdigit (*f))
	flags |= MWIDTH;

      /* Find the maximum field width.  */
      width = 0;
      while (isdigit (*f))
	{
	  width *= 10;
	  width += *f++ - '0';
	}
    got_width:
      if (width == 0)
	width = -1;

      /* Check for type modifiers.  */
      while (*f == 'h' || *f == 'l' || *f == 'L' || *f == 'a' || *f == 'q')
	switch (*f++)
	  {
	  case 'h':
	    /* int's are short int's.  */
	    if (flags & TYPEMOD)
	      /* Signal illegal format element.  */
	      conv_error ();
	    flags |= MSHORT;
	    break;
	  case 'l':
	    if (flags & (MSHORT|MLONGDBL))
	      conv_error ();
	    else if (flags & MLONG)
	      {
		/* A double `l' is equivalent to an `L'.  */
		flags &= ~MLONG;
		flags |= MLONGDBL;
	      }
	    else
	      /* int's are long int's.  */
	      flags |= MLONG;
	    break;
	  case 'q':
	  case 'L':
	    /* double's are long double's, and int's are long long int's.  */
	    if (flags & TYPEMOD)
	      /* Signal illegal format element.  */
	      conv_error ();
	    flags |= MLONGDBL;
	    break;
	  case 'a':
	    if (flags & TYPEMOD)
	      /* Signal illegal format element.  */
	      conv_error ();
	    /* String conversions (%s, %[) take a `char **'
	       arg and fill it in with a malloc'd pointer.  */
	    flags |= MMALLOC;
	    break;
	  }

      /* End of the format string?  */
      if (*f == '\0')
	conv_error ();

      /* We must take care for EINTR errors.  */
      if (c == EOF && errno == EINTR)
	input_error ();

      /* Find the conversion specifier.  */
      fc = *f++;
      if (skip_space || (fc != '[' && fc != 'c' && fc != 'C' && fc != 'n'))
	{
	  /* Eat whitespace.  */
	  do
	    if (inchar () == EOF && errno == EINTR)
	      input_error ();
	  while (isspace (c));
	  my_ungetc (c, s);
	  skip_space = 0;
	}

      switch (fc)
	{
	case '%':	/* Must match a literal '%'.  */
	  c = inchar ();
	  if (c != fc)
	    {
	      my_ungetc (c, s);
	      conv_error ();
	    }
	  break;

	case 'n':	/* Answer number of assignments done.  */
	  /* Corrigendum 1 to ISO C 1990 describes the allowed flags
	     with the 'n' conversion specifier.  */
	  if (!(flags & MSUPPRESS))
	    {
	      /* Don't count the read-ahead.  */
	      if (flags & MLONGDBL)
		*ARG (long int *) = read_in;
	      else if (flags & MLONG)
		*ARG (long int *) = read_in;
	      else if (flags & MSHORT)
		*ARG (short int *) = read_in;
	      else
		*ARG (int *) = read_in;

#ifdef NO_BUG_IN_ISO_C_CORRIGENDUM_1
	      /* We have a severe problem here.  The ISO C standard
		 contradicts itself in explaining the effect of the %n
		 format in `scanf'.  While in ISO C:1990 and the ISO C
		 Amendement 1:1995 the result is described as

		   Execution of a %n directive does not effect the
		   assignment count returned at the completion of
		   execution of the f(w)scanf function.

		 in ISO C Corrigendum 1:1994 the following was added:

		   Subclause 7.9.6.2
		   Add the following fourth example:
		     In:
		       #include <stdio.h>
		       int d1, d2, n1, n2, i;
		       i = sscanf("123", "%d%n%n%d", &d1, &n1, &n2, &d2);
		     the value 123 is assigned to d1 and the value3 to n1.
		     Because %n can never get an input failure the value
		     of 3 is also assigned to n2.  The value of d2 is not
		     affected.  The value 3 is assigned to i.

		 We go for now with the historically correct code fro ISO C,
		 i.e., we don't count the %n assignments.  When it ever
		 should proof to be wrong just remove the #ifdef above.  */
	      ++done;
#endif
	    }
	  break;

	case 'c':	/* Match characters.  */
	  if ((flags & MLONG) == 0)
	    {
	      if (!(flags & MSUPPRESS))
		{
		  str = ARG (char *);
		  if (str == NULL)
		    conv_error ();
		}

	      c = inchar ();
	      if (c == EOF)
		input_error ();

	      if (width == -1)
		width = 1;

	      if (!(flags & MSUPPRESS))
		{
		  do
		    *str++ = c;
		  while (--width > 0 && inchar () != EOF);
		}
	      else
		while (--width > 0 && inchar () != EOF);

	      if (width > 0)
		/* I.e., EOF was read.  */
		--read_in;

	      if (!(flags & MSUPPRESS))
		++done;

	      break;
	    }
	  /* FALLTHROUGH */
	case 'C':
	  /* Get UTF-8 encoded wide character.  Here we assume (as in
	     other parts of the libc) that we only have to handle
	     UTF-8.  */
	  {
	    wint_t val;
	    size_t cnt = 0;
	    int first = 1;

	    if (!(flags & MSUPPRESS))
	      {
		wstr = ARG (wchar_t *);
		if (str == NULL)
		  conv_error ();
	      }

	    do
	      {
#define NEXT_WIDE_CHAR(First)						      \
		c = inchar ();						      \
		if (c == EOF)	{					      \
		  /* EOF is only an error for the first character.  */	      \
		  if (First) {						      \
		    input_error ();                                           \
		  }					                      \
		  else							      \
		    {							      \
		      --read_in;					      \
		      break;						      \
		    }							\
		}						      \
		val = c;						      \
		if (val >= 0x80)					      \
		  {							      \
		    if ((c & 0xc0) == 0x80 || (c & 0xfe) == 0xfe)	      \
		      encode_error ();					      \
		    if ((c & 0xe0) == 0xc0)				      \
		      {							      \
			/* We expect two bytes.  */			      \
			cnt = 1;					      \
			val &= 0x1f;					      \
		      }							      \
		    else if ((c & 0xf0) == 0xe0)			      \
		      {							      \
			/* We expect three bytes.  */			      \
			cnt = 2;					      \
			val &= 0x0f;					      \
		      }							      \
		    else if ((c & 0xf8) == 0xf0)			      \
		      {							      \
			/* We expect four bytes.  */			      \
			cnt = 3;					      \
			val &= 0x07;					      \
		      }							      \
		    else if ((c & 0xfc) == 0xf8)			      \
		      {							      \
			/* We expect five bytes.  */			      \
			cnt = 4;					      \
			val &= 0x03;					      \
		      }							      \
		    else						      \
		      {							      \
			/* We expect six bytes.  */			      \
			cnt = 5;					      \
			val &= 0x01;					      \
		      }							      \
		    							      \
		    do							      \
		      {							      \
			c = inchar ();					      \
			if (c == EOF					      \
			    || (c & 0xc0) == 0x80 || (c & 0xfe) == 0xfe)      \
			  encode_error ();				      \
			val <<= 6;					      \
			val |= c & 0x3f;				      \
		      }							      \
		    while (--cnt > 0);					      \
		  }							      \
									      \
		if (!(flags & MSUPPRESS))				      \
		  *wstr++ = val;					      \
		first = 0

		NEXT_WIDE_CHAR (first);
	      }
	    while (--width > 0);

	    if (width > 0)
	      /* I.e., EOF was read.  */
	      --read_in;

	    if (!(flags & MSUPPRESS))
	      ++done;
	  }
	  break;

	case 's':		/* Read a string.  */
	  if (flags & MLONG)
	    /* We have to process a wide character string.  */
	    goto wide_char_string;

#define STRING_ARG(Str, Type)						      \
	  if (!(flags & MSUPPRESS))					      \
	    {								      \
	      if (flags & MMALLOC)					      \
		{							      \
		  /* The string is to be stored in a malloc'd buffer.  */     \
		  strptr = ARG (char **);				      \
		  if (strptr == NULL)					      \
		    conv_error ();					      \
		  /* Allocate an initial buffer.  */			      \
		  strsize = 100;					      \
		  *strptr = (char*)malloc (strsize * sizeof (Type));		      \
		  Str = (Type *) *strptr;				      \
		}							      \
	      else							      \
		Str = ARG (Type *);					      \
	      if (Str == NULL)						      \
		conv_error ();						      \
	    }
	  STRING_ARG (str, char);

	  c = inchar ();
	  if (c == EOF)
	    input_error ();

	  do
	    {
	      if (isspace (c))
		{
		  my_ungetc (c, s);
		  break;
		}
#define	STRING_ADD_CHAR(Str, c, Type)					      \
	      if (!(flags & MSUPPRESS))					      \
		{							      \
		  *Str++ = c;						      \
		  if ((flags & MMALLOC) && (char *) Str == *strptr + strsize)  \
		    {							      \
		      /* Enlarge the buffer.  */			      \
		      Str = (Type*)realloc (*strptr, strsize * 2 * sizeof (Type));   \
		      if (Str == NULL)					      \
			{						      \
			  /* Can't allocate that much.  Last-ditch effort.  */\
			  Str = (Type*)realloc (*strptr,			      \
					 (strsize + 1) * sizeof (Type));      \
			  if (Str == NULL)				      \
			    {						      \
			      /* We lose.  Oh well.			      \
				 Terminate the string and stop converting,    \
				 so at least we don't skip any input.  */     \
			      ((Type *) (*strptr))[strsize] = '\0';	      \
			      ++done;					      \
			      conv_error ();				      \
			    }						      \
			  else						      \
			    {						      \
			      *strptr = (char *) Str;			      \
			      Str = ((Type *) *strptr) + strsize;	      \
			      ++strsize;				      \
			    }						      \
			}						      \
		      else						      \
			{						      \
			  *strptr = (char *) Str;			      \
			  Str = ((Type *) *strptr) + strsize;		      \
			  strsize *= 2;					      \
			}						      \
		    }							      \
		}
	      STRING_ADD_CHAR (str, c, char);
	    } while ((width <= 0 || --width > 0) && inchar () != EOF);

	  if (!(flags & MSUPPRESS))
	    {
	      *str = '\0';
	      ++done;
	    }
	  break;

	case 'S':
	  /* Wide character string.  */
	wide_char_string:
	  {
	    wint_t val;
	    int first = 1;
	    STRING_ARG (wstr, wchar_t);

	    do
	      {
		size_t cnt = 0;
		NEXT_WIDE_CHAR (first);

		if (iswspace (val))
		  {
		    /* XXX We would have to push back the whole wide char
		       with possibly many bytes.  But since scanf does
		       not make a difference for white space characters
		       we can simply push back a simple <SP> which is
		       guaranteed to be in the [:space:] class.  */
		    my_ungetc (' ', s);
		    break;
		  }

		STRING_ADD_CHAR (wstr, val, wchar_t);
		first = 0;
	      }
	    while (width <= 0 || --width > 0);

	    if (!(flags & MSUPPRESS))
	      {
		*wstr = L'\0';
		++done;
	      }
	  }
	  break;

	case 'x':	/* Hexadecimal integer.  */
	case 'X':	/* Ditto.  */
	  base = 16;
	  number_signed = 0;
	  goto number;

	case 'o':	/* Octal integer.  */
	  base = 8;
	  number_signed = 0;
	  goto number;

	case 'u':	/* Unsigned decimal integer.  */
	  base = 10;
	  number_signed = 0;
	  goto number;

	case 'd':	/* Signed decimal integer.  */
	  base = 10;
	  number_signed = 1;
	  goto number;

	case 'i':	/* Generic number.  */
	  base = 0;
	  number_signed = 1;

	number:
	  c = inchar ();
	  if (c == EOF)
	    input_error ();

	  /* Check for a sign.  */
	  if (c == '-' || c == '+')
	    {
	      ADDW (c);
	      if (width > 0)
		--width;
	      c = inchar ();
	    }

	  /* Look for a leading indication of base.  */
	  if (width != 0 && c == '0')
	    {
	      if (width > 0)
		--width;

	      ADDW (c);
	      c = inchar ();

	      if (width != 0 && tolower (c) == 'x')
		{
		  if (base == 0)
		    base = 16;
		  if (base == 16)
		    {
		      if (width > 0)
			--width;
		      c = inchar ();
		    }
		}
	      else if (base == 0)
		base = 8;
	    }

	  if (base == 0)
	    base = 10;

	  /* Read the number into workspace.  */
	  while (c != EOF && width != 0)
	    {
	      if (base == 16 ? !isxdigit (c) :
		  ((!isdigit (c) || c - '0' >= base) &&
		   !((flags & MGROUP) && base == 10 && c == thousands)))
		break;
	      ADDW (c);
	      if (width > 0)
		--width;

	      c = inchar ();
	    }

	  /* The just read character is not part of the number anymore.  */
	  my_ungetc (c, s);

	  if (wpsize == 0 ||
	      (wpsize == 1 && (wp[0] == '+' || wp[0] == '-')))
	    /* There was no number.  */
	    conv_error ();

	  /* Convert the number.  */
	  ADDW ('\0');
	  if (flags & MLONGDBL)
	    {
//	      if (number_signed)
//		num.q = __strtoq_internal (wp, &tw, base, flags & GROUP);
//	      else
//		num.uq = __strtouq_internal (wp, &tw, base, flags & GROUP);
	    }
	  else
	    {
	      if (number_signed)
		num.l = __strtol_internal (wp, &tw, base, flags & MGROUP);
	      else
		num.ul = __strtoul_internal (wp, &tw, base, flags & MGROUP);
	    }
	  if (wp == tw)
	    conv_error ();

	  if (!(flags & MSUPPRESS))
	  {
	    if (! number_signed)
		{
			if (flags & MLONGDBL) {
		    		*ARG (unsigned MLONGLONG int *) = num.uq;
			}
			else if (flags & MLONG)
				*ARG (unsigned long int *) = num.ul;
			else if (flags & MSHORT)
				*ARG (unsigned short int *) = (unsigned short int) num.ul;
			else
				*ARG (unsigned int *) = (unsigned int) num.ul;
		}
	    else
		{
			if (flags & MLONGDBL) {
			    *ARG (MLONGLONG int *) = num.q;
			}
			else if (flags & MLONG)
				*ARG (long int *) = num.l;
			else if (flags & MSHORT)
				*ARG (short int *) = (short int) num.l;
			else
				*ARG (int *) = (int) num.l;
		}
	    ++done;
	  }
	  break;

	case 'e':	/* Floating-point numbers.  */
	case 'E':
	case 'f':
	case 'g':
	case 'G':
	  c = inchar ();
	  if (c == EOF)
	    input_error ();

	  /* Check for a sign.  */
	  if (c == '-' || c == '+')
	    {
	      negative = c == '-';
	      if (inchar () == EOF)
		/* EOF is only an input error before we read any chars.  */
		conv_error ();
	      if (width > 0)
		--width;
	    }
	  else
	    negative = 0;

	  got_dot = got_e = 0;
	  do
	    {
	      if (isdigit (c))
		ADDW (c);
	      else if (got_e && wp[wpsize - 1] == 'e'
		       && (c == '-' || c == '+'))
		ADDW (c);
	      else if (wpsize > 0 && !got_e && tolower (c) == 'e')
		{
		  ADDW ('e');
		  got_e = got_dot = 1;
		}
	      else if (c == decimal && !got_dot)
		{
		  ADDW (c);
		  got_dot = 1;
		}
	      else if ((flags & MGROUP) && c == thousands && !got_dot)
		ADDW (c);
	      else
		{
		  /* The last read character is not part of the number
		     anymore.  */
		  my_ungetc (c, s);
		  break;
		}
	      if (width > 0)
		--width;
	    }
	  while (width != 0 && inchar () != EOF);

	  if (wpsize == 0)
	    conv_error ();

	  /* Convert the number.  */
	  ADDW ('\0');
	  if (flags & MLONGDBL)
	    {
	      long double d = __strtold_internal (wp, &tw, flags & MGROUP);
	      if (!(flags & MSUPPRESS) && tw != wp)
		*ARG (long double *) = negative ? -d : d;
	    }
	  else if (flags & MLONG)
	    {
	      double d = __strtod_internal (wp, &tw, flags & MGROUP);
	      if (!(flags & MSUPPRESS) && tw != wp)
		*ARG (double *) = negative ? -d : d;
	    }
	  else
	    {
	      float d = __strtof_internal (wp, &tw, flags & MGROUP);
	      if (!(flags & MSUPPRESS) && tw != wp)
		*ARG (float *) = negative ? -d : d;
	    }

	  if (tw == wp)
	    conv_error ();

	  if (!(flags & MSUPPRESS))
	    ++done;
	  break;

	case '[':	/* Character class.  */
	  if (flags & MLONG)
	    {
	      STRING_ARG (wstr, wchar_t);
	      c = '\0';		/* This is to keep gcc quiet.  */
	    }
	  else
	    {
	      STRING_ARG (str, char);

	      c = inchar ();
	      if (c == EOF)
		input_error ();
	    }

	  if (*f == '^')
	    {
	      ++f;
	      not_in = 1;
	    }
	  else
	    not_in = 0;

	  /* Fill WP with byte flags indexed by character.
	     We will use this flag map for matching input characters.  */
	  if (wpmax < UCHAR_MAX)
	    {
	      wpmax = UCHAR_MAX;
	      wp = (char *) alloca (wpmax);
	    }
	  memset (wp, 0, UCHAR_MAX);

	  fc = *f;
	  if (fc == ']' || fc == '-')
	    {
	      /* If ] or - appears before any char in the set, it is not
		 the terminator or separator, but the first char in the
		 set.  */
	      wp[fc] = 1;
	      ++f;
	    }

	  while ((fc = *f++) != '\0' && fc != ']')
	    {
	      if (fc == '-' && *f != '\0' && *f != ']' &&
		  (unsigned char) f[-2] <= (unsigned char) *f)
		{
		  /* Add all characters from the one before the '-'
		     up to (but not including) the next format char.  */
		  for (fc = f[-2]; fc < *f; ++fc)
		    wp[fc] = 1;
		}
	      else
		/* Add the character to the flag map.  */
		wp[fc] = 1;
	    }
	  if (fc == '\0')
	    {
	      if (!(flags & MLONG))
		my_ungetc (c, s);
	      conv_error();
	    }

	  if (flags & MLONG)
	    {
	      wint_t val;
	      int first = 1;

	      do
		{
		  size_t cnt = 0;
		  NEXT_WIDE_CHAR (first);
		  if (val > 255 || wp[val] == not_in)
		    {
		      /* XXX We have a problem here.  We read a wide
			 character and this possibly took several
			 bytes.  But we can only push back one single
			 character.  To be sure we don't create wrong
			 input we push it back only in case it is
			 representable within one byte.  */
		      if (val < 0x80)
			my_ungetc (val, s);
		      break;
		    }
		  STRING_ADD_CHAR (wstr, val, wchar_t);
		  if (width > 0)
		    --width;
		  first = 0;
		}
	      while (width != 0);

	      if (first)
		conv_error ();

	      if (!(flags & MSUPPRESS))
		{
		  *wstr = L'\0';
		  ++done;
		}
	    }
	  else
	    {
	      num.ul = read_in - 1; /* -1 because we already read one char.  */
	      do
		{
		  if (wp[c] == not_in)
		    {
		      my_ungetc (c, s);
		      break;
		    }
		  STRING_ADD_CHAR (str, c, char);
		  if (width > 0)
		    --width;
		}
	      while (width != 0 && inchar () != EOF);

	      if (read_in == num.ul)
		conv_error ();

	      if (!(flags & MSUPPRESS))
		{
		  *str = '\0';
		  ++done;
		}
	    }
	  break;

	case 'p':	/* Generic pointer.  */
	  base = 16;
	  /* A PTR must be the same size as a `long int'.  */
	  flags &= ~(MSHORT|MLONGDBL);
	  flags |= MLONG;
	  number_signed = 0;
	  goto number;
	}
    }

  /* The last thing we saw int the format string was a white space.
     Consume the last white spaces.  */
  if (skip_space)
    {
      do
	c = inchar ();
      while (isspace (c));
      my_ungetc (c, s);
    }

  return done;
}

static double __strtod_internal  (const char *__nptr,char **__endptr, int __group)
{
	return strtod(__nptr,__endptr);
}
static float __strtof_internal (const char *__nptr, char **__endptr,int __group)
{
	return (float)strtod(__nptr,__endptr);
}
static double powten[] =
{
  1e1L, 1e2L, 1e4L, 1e8L, 1e16L, 1e32L, 1e64L, 1e128L, 1e256L,
  /*1e512L, 1e512L*1e512L, 1e2048L, 1e4096L*///cjh
};

static long double __strtold_internal  (const char *s,char **sret, int __group)
{

  long double r;		/* result */
  int e, ne;			/* exponent */
  int sign;			/* +- 1.0 */
  int esign;
  int flags=0;
  int l2powm1;

  r = 0.0L;
  sign = 1;
  e = ne = 0;
  esign = 1;

  while(*s && isspace(*s))
    s++;

  if (*s == '+')
    s++;
  else if (*s == '-')
  {
    sign = -1;
    s++;
  }

  while ((*s >= '0') && (*s <= '9'))
  {
    flags |= 1;
    r *= 10.0L;
    r += *s - '0';
    s++;
  }

  if (*s == '.')
  {
    s++;
    while ((*s >= '0') && (*s <= '9'))
    {
      flags |= 2;
      r *= 10.0L;
      r += *s - '0';
      s++;
      ne++;
    }
  }
  if (flags == 0)
  {
    if (sret)
      *sret = (char *)s;
    return 0.0L;
  }

  if ((*s == 'e') || (*s == 'E'))
  {
    s++;
    if (*s == '+')
      s++;
    else if (*s == '-')
    {
      s++;
      esign = -1;
    }
    while ((*s >= '0') && (*s <= '9'))
    {
      e *= 10;
      e += *s - '0';
      s++;
    }
  }
  if (esign < 0)
  {
    esign = -esign;
    e = -e;
  }
  e = e - ne;
  if (e < -4096)
  {
    /* possibly subnormal number, 10^e would overflow */
    r *= 1.0e-2048L;
    e += 2048;
  }
  if (e < 0)
  {
    e = -e;
    esign = -esign;
  }
  if (e >= 8192)
    e = 8191;
  if (e)
  {
    double d = 1.0L;
    l2powm1 = 0;
    while (e)
    {
      if (e & 1)
	d *= powten[l2powm1];
      e >>= 1;
      l2powm1++;
    }
    if (esign > 0)
      r *= d;
    else
      r /= d;
  }
  if (sret)
    *sret = (char *)s;
  return r * sign;

  return 0;
}
static long int __strtol_internal (const char *__nptr, char **__endptr,	int __base, int __group)
{
	return strtol(__nptr,__endptr, __base);
}
static unsigned long int __strtoul_internal  (const char *__nptr,  char **__endptr, int __base, int __group)
{
	return strtoul(__nptr,__endptr, __base);
}

/* Read formatted input from S according to the format
   string FORMAT, using the argument list in ARG.  */
static int my_vsscanf (const char *s,const char *format,va_list arg)
{
  MYFILE f;

//   if (s == NULL)
//     {
//       __set_errno (EINVAL);
//       return -1;
//     }

  memset ((void *) &f, 0, sizeof (f));

  f._flag = _IOREAD;
  f._ptr = (char *)s;
  f._base = (char *)s;
  f._bufsiz = strlen(s);
  f._cnt = f._bufsiz;

  return __vfscanf (&f, format, arg);
}

int sscanf (const char *s,const char *format, ...)
{
	va_list arg;
	int done;

	va_start (arg, format);
	done = my_vsscanf (s, format, arg);
	va_end (arg);

	return done;
}

void __assert_func(const char *file, int line, const char *a, const char *b)
{

}

#endif

void badaAssert(const char* pFunction, int lineNumber, const char* pszContent)
{
	int iRet = 0;
	MessageBox msgBox;
	String strContent;
	strContent.Append("Func:");
	strContent.Append(pFunction);
	strContent.Append(",Line:");
	strContent.Append(lineNumber);
	strContent.Append(": (");
	strContent.Append(pszContent);
	strContent.Append(" )fails!");
	msgBox.Construct("Assert", strContent, MSGBOX_STYLE_OK);
	msgBox.ShowAndWait(iRet);
	Application::GetInstance()->Terminate();
}

}


code:
/****************************************************************************
Copyright (c) 2010 cocos2d-x.org

http://www.cocos2d-x.org

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, sublicense, 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 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 NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS 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.
****************************************************************************/

#ifndef __CC_PLATFORMFUNC_BADA_H__
#define __CC_PLATFORMFUNC_BADA_H__

#ifdef __cplusplus
extern "C" {
#endif

#ifndef CC_BADA_2_0

int CC_DLL printf(const char* format, ...);
int CC_DLL sprintf(char* buf, const char *format, ...);
int CC_DLL sscanf (const char *s,const char *format, ...);

#endif

void CC_DLL badaAssert(const char* pFunction, int lineNumber, const char* pszContent);

#ifdef __cplusplus
}
#endif

#endif /* __CC_PLATFORMFUNC_BADA_H__ */

license: mit


code:
/* $Change: 608281 $ */
/* -*- mode: c; tab-width: 8; -*- */
/* vi: set sw=4 ts=8: */
/* Reference version of egl.h for EGL 1.4.
 * $Revision: #3 $ on $Date: 2010/08/05 $
 */

/*
** Copyright (c) 2007-2009 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE 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 NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/

/*! \file egl.h
    \brief egl header file.

    egl header file.
*/

#ifndef __egl_h_
#define __egl_h_

/* All platform-dependent types and macro boilerplate (such as EGLAPI
 * and EGLAPIENTRY) should go in eglplatform.h.
 */
#include "eglplatform.h"

#ifdef __cplusplus
extern "C" {
#endif

/**
 * @addtogroup opengles
 *
 * @{
 */

/* EGL Types */
/* EGLint is defined in eglplatform.h */

/*! \var typedef unsigned int EGLBoolean
    \brief A type definition for EGLBoolean.
*/
typedef unsigned int EGLBoolean;

/*! \var typedef unsigned int EGLenum
    \brief A type definition for EGLenum.
*/
typedef unsigned int EGLenum;

/*! \var typedef void *EGLConfig
    \brief A type definition for EGLConfig.
*/
typedef void *EGLConfig;

/*! \var typedef void *EGLContext
    \brief A type definition for EGLContext.
*/
typedef void *EGLContext;

/*! \var typedef void *EGLDisplay
    \brief A type definition for EGLDisplay.
*/
typedef void *EGLDisplay;

/*! \var typedef void *EGLSurface
    \brief A type definition for EGLSurface.
*/
typedef void *EGLSurface;

/*! \var typedef void *EGLClientBuffer
    \brief A type definition for EGLClientBuffer.
*/
typedef void *EGLClientBuffer;

/* EGL Versioning */
#define EGL_VERSION_1_0			1
#define EGL_VERSION_1_1			1
#define EGL_VERSION_1_2			1
#define EGL_VERSION_1_3			1
#define EGL_VERSION_1_4			1

/* EGL Enumerants. Bitmasks and other exceptional cases aside, most
 * enums are assigned unique values starting at 0x3000.
 */

/* EGL aliases */
#define EGL_FALSE			0
#define EGL_TRUE			1

/* Out-of-band handle values */
#define EGL_DEFAULT_DISPLAY		((EGLNativeDisplayType)0)
#define EGL_NO_CONTEXT			((EGLContext)0)
#define EGL_NO_DISPLAY			((EGLDisplay)0)
#define EGL_NO_SURFACE			((EGLSurface)0)

/* Out-of-band attribute value */
#define EGL_DONT_CARE			((EGLint)-1)

/* Errors / GetError return values */
#define EGL_SUCCESS			0x3000
#define EGL_NOT_INITIALIZED		0x3001
#define EGL_BAD_ACCESS			0x3002
#define EGL_BAD_ALLOC			0x3003
#define EGL_BAD_ATTRIBUTE		0x3004
#define EGL_BAD_CONFIG			0x3005
#define EGL_BAD_CONTEXT			0x3006
#define EGL_BAD_CURRENT_SURFACE		0x3007
#define EGL_BAD_DISPLAY			0x3008
#define EGL_BAD_MATCH			0x3009
#define EGL_BAD_NATIVE_PIXMAP		0x300A
#define EGL_BAD_NATIVE_WINDOW		0x300B
#define EGL_BAD_PARAMETER		0x300C
#define EGL_BAD_SURFACE			0x300D
#define EGL_CONTEXT_LOST		0x300E	/* EGL 1.1 - IMG_power_management */

/* Reserved 0x300F-0x301F for additional errors */

/* Config attributes */
#define EGL_BUFFER_SIZE			0x3020
#define EGL_ALPHA_SIZE			0x3021
#define EGL_BLUE_SIZE			0x3022
#define EGL_GREEN_SIZE			0x3023
#define EGL_RED_SIZE			0x3024
#define EGL_DEPTH_SIZE			0x3025
#define EGL_STENCIL_SIZE		0x3026
#define EGL_CONFIG_CAVEAT		0x3027
#define EGL_CONFIG_ID			0x3028
#define EGL_LEVEL			0x3029
#define EGL_MAX_PBUFFER_HEIGHT		0x302A
#define EGL_MAX_PBUFFER_PIXELS		0x302B
#define EGL_MAX_PBUFFER_WIDTH		0x302C
#define EGL_NATIVE_RENDERABLE		0x302D
#define EGL_NATIVE_VISUAL_ID		0x302E
#define EGL_NATIVE_VISUAL_TYPE		0x302F
#define EGL_PRESERVED_RESOURCES		0x3030
#define EGL_SAMPLES			0x3031
#define EGL_SAMPLE_BUFFERS		0x3032
#define EGL_SURFACE_TYPE		0x3033
#define EGL_TRANSPARENT_TYPE		0x3034
#define EGL_TRANSPARENT_BLUE_VALUE	0x3035
#define EGL_TRANSPARENT_GREEN_VALUE	0x3036
#define EGL_TRANSPARENT_RED_VALUE	0x3037
#define EGL_NONE			0x3038	/* Attrib list terminator */
#define EGL_BIND_TO_TEXTURE_RGB		0x3039
#define EGL_BIND_TO_TEXTURE_RGBA	0x303A
#define EGL_MIN_SWAP_INTERVAL		0x303B
#define EGL_MAX_SWAP_INTERVAL		0x303C
#define EGL_LUMINANCE_SIZE		0x303D
#define EGL_ALPHA_MASK_SIZE		0x303E
#define EGL_COLOR_BUFFER_TYPE		0x303F
#define EGL_RENDERABLE_TYPE		0x3040
#define EGL_MATCH_NATIVE_PIXMAP		0x3041	/* Pseudo-attribute (not queryable) */
#define EGL_CONFORMANT			0x3042

/* Reserved 0x3041-0x304F for additional config attributes */

/* Config attribute values */
#define EGL_SLOW_CONFIG			0x3050	/* EGL_CONFIG_CAVEAT value */
#define EGL_NON_CONFORMANT_CONFIG	0x3051	/* EGL_CONFIG_CAVEAT value */
#define EGL_TRANSPARENT_RGB		0x3052	/* EGL_TRANSPARENT_TYPE value */
#define EGL_RGB_BUFFER			0x308E	/* EGL_COLOR_BUFFER_TYPE value */
#define EGL_LUMINANCE_BUFFER		0x308F	/* EGL_COLOR_BUFFER_TYPE value */

/* More config attribute values, for EGL_TEXTURE_FORMAT */
#define EGL_NO_TEXTURE			0x305C
#define EGL_TEXTURE_RGB			0x305D
#define EGL_TEXTURE_RGBA		0x305E
#define EGL_TEXTURE_2D			0x305F

/* Config attribute mask bits */
#define EGL_PBUFFER_BIT			0x0001	/* EGL_SURFACE_TYPE mask bits */
#define EGL_PIXMAP_BIT			0x0002	/* EGL_SURFACE_TYPE mask bits */
#define EGL_WINDOW_BIT			0x0004	/* EGL_SURFACE_TYPE mask bits */
#define EGL_VG_COLORSPACE_LINEAR_BIT	0x0020	/* EGL_SURFACE_TYPE mask bits */
#define EGL_VG_ALPHA_FORMAT_PRE_BIT	0x0040	/* EGL_SURFACE_TYPE mask bits */
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200	/* EGL_SURFACE_TYPE mask bits */
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400	/* EGL_SURFACE_TYPE mask bits */

#define EGL_OPENGL_ES_BIT		0x0001	/* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENVG_BIT			0x0002	/* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENGL_ES2_BIT		0x0004	/* EGL_RENDERABLE_TYPE mask bits */
#define EGL_OPENGL_BIT			0x0008	/* EGL_RENDERABLE_TYPE mask bits */

/* QueryString targets */
#define EGL_VENDOR			0x3053
#define EGL_VERSION			0x3054
#define EGL_EXTENSIONS			0x3055
#define EGL_CLIENT_APIS			0x308D

/* QuerySurface / SurfaceAttrib / CreatePbufferSurface targets */
#define EGL_HEIGHT			0x3056
#define EGL_WIDTH			0x3057
#define EGL_LARGEST_PBUFFER		0x3058
#define EGL_TEXTURE_FORMAT		0x3080
#define EGL_TEXTURE_TARGET		0x3081
#define EGL_MIPMAP_TEXTURE		0x3082
#define EGL_MIPMAP_LEVEL		0x3083
#define EGL_RENDER_BUFFER		0x3086
#define EGL_VG_COLORSPACE		0x3087
#define EGL_VG_ALPHA_FORMAT		0x3088
#define EGL_HORIZONTAL_RESOLUTION	0x3090
#define EGL_VERTICAL_RESOLUTION		0x3091
#define EGL_PIXEL_ASPECT_RATIO		0x3092
#define EGL_SWAP_BEHAVIOR		0x3093
#define EGL_MULTISAMPLE_RESOLVE		0x3099

/* EGL_RENDER_BUFFER values / BindTexImage / ReleaseTexImage buffer targets */
#define EGL_BACK_BUFFER			0x3084
#define EGL_SINGLE_BUFFER		0x3085

/* OpenVG color spaces */
#define EGL_VG_COLORSPACE_sRGB		0x3089	/* EGL_VG_COLORSPACE value */
#define EGL_VG_COLORSPACE_LINEAR	0x308A	/* EGL_VG_COLORSPACE value */

/* OpenVG alpha formats */
#define EGL_VG_ALPHA_FORMAT_NONPRE	0x308B	/* EGL_ALPHA_FORMAT value */
#define EGL_VG_ALPHA_FORMAT_PRE		0x308C	/* EGL_ALPHA_FORMAT value */

/* Constant scale factor by which fractional display resolutions &
 * aspect ratio are scaled when queried as integer values.
 */
#define EGL_DISPLAY_SCALING		10000

/* Unknown display resolution/aspect ratio */
#define EGL_UNKNOWN			((EGLint)-1)

/* Back buffer swap behaviors */
#define EGL_BUFFER_PRESERVED		0x3094	/* EGL_SWAP_BEHAVIOR value */
#define EGL_BUFFER_DESTROYED		0x3095	/* EGL_SWAP_BEHAVIOR value */

/* CreatePbufferFromClientBuffer buffer types */
#define EGL_OPENVG_IMAGE		0x3096

/* QueryContext targets */
#define EGL_CONTEXT_CLIENT_TYPE		0x3097

/* CreateContext attributes */
#define EGL_CONTEXT_CLIENT_VERSION	0x3098

/* Multisample resolution behaviors */
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A	/* EGL_MULTISAMPLE_RESOLVE value */
#define EGL_MULTISAMPLE_RESOLVE_BOX	0x309B	/* EGL_MULTISAMPLE_RESOLVE value */

/* BindAPI/QueryAPI targets */
#define EGL_OPENGL_ES_API		0x30A0
#define EGL_OPENVG_API			0x30A1
#define EGL_OPENGL_API			0x30A2

/* GetCurrentSurface targets */
#define EGL_DRAW			0x3059
#define EGL_READ			0x305A

/* WaitNative engines */
#define EGL_CORE_NATIVE_ENGINE		0x305B

/* EGL 1.2 tokens renamed for consistency in EGL 1.3 */
#define EGL_COLORSPACE			EGL_VG_COLORSPACE
#define EGL_ALPHA_FORMAT		EGL_VG_ALPHA_FORMAT
#define EGL_COLORSPACE_sRGB		EGL_VG_COLORSPACE_sRGB
#define EGL_COLORSPACE_LINEAR		EGL_VG_COLORSPACE_LINEAR
#define EGL_ALPHA_FORMAT_NONPRE		EGL_VG_ALPHA_FORMAT_NONPRE
#define EGL_ALPHA_FORMAT_PRE		EGL_VG_ALPHA_FORMAT_PRE

/* EGL extensions must request enum blocks from the Khronos
 * API Registrar, who maintains the enumerant registry. Submit
 * a bug in Khronos Bugzilla against task "Registry".
 */

/*
** FIXME: The EGL_SEQUENCE_ITEM_SYMB token is temporary until an
** offical name and value are assigned.
*/
#define EGL_SEQUENCE_ITEM_SYMB		0x6000

/* EGL Functions */

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLint 		eglGetError(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLDisplay  eglGetDisplay(EGLNativeDisplayType display_id);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglTerminate(EGLDisplay dpy);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
const char *  eglQueryString(EGLDisplay dpy, EGLint name);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLSurface  eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLSurface  eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLSurface  eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config,EGLNativePixmapType pixmap,const EGLint *attrib_list);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglDestroySurface(EGLDisplay dpy, EGLSurface surface);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglQuerySurface(EGLDisplay dpy, EGLSurface surface,EGLint attribute, EGLint *value);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglBindAPI(EGLenum api);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLenum  	eglQueryAPI(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglWaitClient(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglReleaseThread(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLSurface  eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);

/*
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean  eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglSwapInterval(EGLDisplay dpy,EGLint interval);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLContext eglCreateContext(EGLDisplay dpy,EGLConfig config, EGLContext share_context, const EGLint *attrib_list);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglDestroyContext(EGLDisplay dpy,EGLContext ctx);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglMakeCurrent(EGLDisplay dpy,EGLSurface draw, EGLSurface read,EGLContext ctx);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLContext eglGetCurrentContext(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLSurface eglGetCurrentSurface(EGLint readdraw);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLDisplay eglGetCurrentDisplay(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglQueryContext(EGLDisplay dpy,EGLContext ctx, EGLint attribute,EGLint *value);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglWaitGL(void);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglWaitNative(EGLint engine);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglSwapBuffers(EGLDisplay dpy,EGLSurface surface);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglCopyBuffers(EGLDisplay dpy,EGLSurface surface, EGLNativePixmapType target);

/* This is a generic function pointer type, whose name indicates it must
 * be cast to the proper type *and calling convention* before use.
 */
/*! \var typedef void (*__eglMustCastToProperFunctionPointerType)(void)
    \brief A type definition for __eglMustCastToProperFunctionPointerType.
*/
typedef void (*__eglMustCastToProperFunctionPointerType)(void);

/* Now, define eglGetProcAddress using the generic function ptr. type */
/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname);

/**
 * You can find more details at the Khronos Group site: http://www.khronos.org/registry/egl
 */
EGLBoolean eglUpdateBufferOSP(EGLDisplay dpy,EGLSurface surface);

/**
 * @}
 */

#ifdef __cplusplus
}
#endif

#endif /* __egl_h_ */


code:
/* $Change: 597344 $ */
#ifndef _egl_macro_h_
#define _egl_macro_h_

#define eglGetError sglGetError
#define eglGetDisplay 	sglGetDisplay
#define eglInitialize	sglInitialize
#define eglTerminate sglTerminate
#define eglQueryString sglQueryString
#define eglGetConfigs sglGetConfigs
#define eglChooseConfig sglChooseConfig
#define eglGetConfigAttrib sglGetConfigAttrib
#define eglCreateWindowSurface sglCreateWindowSurface
#define eglCreatePbufferSurface sglCreatePbufferSurface
#define eglCreatePixmapSurface sglCreatePixmapSurface
#define eglDestroySurface	sglDestroySurface
#define eglQuerySurface sglQuerySurface
#define eglBindAPI sglBindAPI
#define eglQueryAPI sglQueryAPI
#define eglWaitClient sglWaitClient
#define eglReleaseThread sglReleaseThread
#define eglCreatePbufferFromClientBuffer sglCreatePbufferFromClientBuffer
#define eglSurfaceAttrib sglSurfaceAttrib
#define eglBindTexImage sglBindTexImage
#define eglReleaseTexImage sglReleaseTexImage
#define eglSwapInterval sglSwapInterval
#define eglCreateContext sglCreateContext
#define eglDestroyContext sglDestroyContext
#define eglMakeCurrent sglMakeCurrent
#define eglGetCurrentContext sglGetCurrentContext
#define eglGetCurrentSurface sglGetCurrentSurface
#define eglGetCurrentDisplay sglGetCurrentDisplay
#define eglQueryContext sglQueryContext
#define eglWaitGL sglWaitGL
#define eglWaitNative sglWaitNative
#define eglSwapBuffers sglSwapBuffers
#define eglCopyBuffers sglCopyBuffers
#define eglGetProcAddress sglGetProcAddress
#define eglUpdateBufferOSP sglUpdateBufferOSP

#endif // _egl_macro_h_


code:
/* $Change: 608281 $ */

/*! \file eglplatform.h
    \brief eglplatform header file.

    eglplatform header file.
*/
#ifndef __eglplatform_h_
#define __eglplatform_h_

/*
** Copyright (c) 2007-2009 The Khronos Group Inc.
**
** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions:
**
** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials.
**
** THE MATERIALS ARE 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 NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 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
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
 */

/* Platform-specific types and definitions for egl.h
 * $Revision: #3 $ on $Date: 2010/08/05 $
 *
 * Adopters may modify khrplatform.h and this file to suit their platform.
 * You are encouraged to submit all modifications to the Khronos group so that
 * they can be included in future versions of this file.  Please submit changes
 * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
 * by filing a bug against product "EGL" component "Registry".
 */

//}}}
//
//namespace Osp { namespace Ui { class Control; }; };
//namespace Osp { namespace Graphics { class Bitmap; }; };
//
//namespace Osp { namespace Graphics { namespace Opengl {

#include "khrplatform.h"

/* Macros used in EGL function prototype declarations.
 *
 * EGL functions should be prototyped as:
 *
 * EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
 * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
 *
 * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
 */

/**
 * @addtogroup opengles
 *
 * @{
 */

#ifndef _WIN32
#define EGLAPI
#define EGLAPIENTRY
#else
#ifndef EGLAPIENTRY
#define EGLAPIENTRY __stdcall
#endif
#ifndef EGLAPI
#define EGLAPI
#endif
#endif

/*
** Types and resources
*/

/*! \var typedef int EGLint
    \brief A type definition for EGLConfig.
*/
typedef int EGLint;

#ifdef _WIN32_bada
typedef void *EGLNativeDisplayType;
class Osp::Ui::Control;
typedef Osp::Ui::Control *EGLNativeWindowType;
class Osp::Graphics::Bitmap;
typedef Bitmap *EGLNativePixmapType;

#elif FEATURE_SYSLSI_S5PC110
typedef int  EGLNativeDisplayType;
typedef void *EGLNativeWindowType;
typedef struct
{
	void	*pBuffer;
	long	lWidth;
	long	lHeight;
	enum
	{
		NUEGL_PIXELFORMAT_565 = 0,
		NUEGL_PIXELFORMAT_4444 = 1,
		NUEGL_PIXELFORMAT_8888 = 2,
		NUEGL_PIXELFORMAT_1555 = 3,
		NUEGL_PIXELFORMAT_force_to_32_bits = 0x12345678
	} ePixelFormat;
	enum
	{
		NUEGL_ROTATE_0 = 0,
		NUEGL_ROTATE_90 = 1,
		NUEGL_ROTATE_180 = 2,
		NUEGL_ROTATE_270 = 3,
		NUEGL_ROTATE_force_to_32_bits = 0x12345678
	} eRotation;
} sEGLNativePixmapType;
typedef sEGLNativePixmapType *EGLNativePixmapType;
#else

/*! \var typedef void *EGLNativeDisplayType
    \brief A type definition for EGLNativeDisplayType.
*/
typedef void *EGLNativeDisplayType;

/*! \var typedef void *EGLNativeWindowType
    \brief A type definition for EGLNativeWindowType.
*/
typedef void *EGLNativeWindowType;

/*! \var typedef void *EGLNativePixmapType
    \brief A type definition for EGLNativePixmapType.
*/
typedef void *EGLNativePixmapType;
#endif

/*! \var typedef EGLNativeDisplayType NativeDisplayType
    \brief A type definition for NativeDisplayType.
*/
typedef EGLNativeDisplayType NativeDisplayType;

/*! \var typedef EGLNativePixmapType  NativePixmapType
    \brief A type definition for NativePixmapType.
*/
typedef EGLNativePixmapType  NativePixmapType;

/*! \var typedef EGLNativeWindowType  NativeWindowType
    \brief A type definition for NativeWindowType.
*/
typedef EGLNativeWindowType  NativeWindowType;

#include "egl_macro.h"

/**
 * @}
 */

#endif /* __eglplatform_h_ */