/*

* Copyright (c) 1999 - 2001 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

 /*

    $Workfile: scr_conv.c $

    Purpose: handle parameter parsing in urls

    $History: scr_conv.c $

  */

#include "scr_conv.h"

#include "scr_core.h"

#include "scr_valexpr.h"

#include "nwx_mem.h"

#include "nwx_string.h"

#include "nwx_url_utils.h"

#include "nwx_math.h"

#include "nwx_float.h"

#include "nw_wae_reader.h"

#include "BrsrStatusCodes.h"

#define NO_PRECISION  -1

#define NO_WIDTH      -1

/*

**-------------------------------------------------------------------------

**  Internal Prototypes

**-------------------------------------------------------------------------

*/

static NW_Int32 Snprintf(NW_Ucs2 *buf, const NW_Int32 buf_len, const NW_Ucs2 *format, ... );

/*

**-------------------------------------------------------------------------

**  Internal Functions

**-------------------------------------------------------------------------

*/

/* Implementation of Snprintf exists to avoid NW_Str_Vsnprintf get duplicated */

static NW_Int32 Snprintf(NW_Ucs2 *buf, const NW_Int32 buf_len, const NW_Ucs2 *format, ... )

{

  va_list args;

  NW_Int32  status;

  va_start (args, format );

  /* buf_len - 1, for null termination */

  status = NW_Str_Vsnprintf ( buf, buf_len - 1, format, &args );

  va_end (args);

  return status;

}

NW_Ucs2 *str2ucs2(str_t str)

{

  NW_Ucs2 *res = 0;

  NW_Int32 len;

  len = str_len(str);

  res = NW_Str_New(len);

  if (!res)

  {

    set_error_code(SCR_ERROR_OUT_OF_MEMORY);

    return 0;

  }

  if (len > 0) NW_Mem_memcpy(res, &str[1], len*sizeof(NW_Ucs2));

  res[len] = 0;

  return res;

}

char *str2ascii(str_t s)

{

  NW_Int32  len, i;

  NW_Uint16 wc;

  char *res;

  len = str_len(s);

  res = (char*)NW_Mem_Malloc(len + 1);

  if (!res)

  {

    set_error_code(SCR_ERROR_OUT_OF_MEMORY);

    return 0;

  }

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

  {

    wc = s[1 + i];

    if (wc > 127)

    {

      NW_Mem_Free(res);

      return 0;

    }

    res[i] = (char)wc;

  }

  res[len] = 0;

  return res;

}

NW_Bool str2int(str_t s, NW_Int32  *res, NW_Bool *consumeAll)

{

  NW_Int32  start = 0, len = str_len(s), end, i;

  str_t substr;

  NW_Ucs2 *wstr;

  NW_Ucs2 *p = NULL; /*TODO:  JW fix in WAVE*/

  NW_Ucs2 c;

  TBrowserStatusCode status;

  NW_ASSERT(s);

  NW_ASSERT(res);

  NW_ASSERT(consumeAll);

  *consumeAll = NW_FALSE;

  /* skipping white spaces */

  while ( (start < len) && (scr_charat(s, start) <= 32) ) {

    start++;

  }

  i = start;

  if (i == len) {

    return NW_FALSE; /* reach the end of the string */

  }

  c = scr_charat(s, i);

  if ((c != '+') && (c != '-') && !NW_Str_Isdigit(c)) {

    return NW_FALSE;

  }

  i++;

  if ( ((c == '+') || (c == '-')) &&

       ((i >= len) || !NW_Str_Isdigit(scr_charat(s, i))) )

  {

    return NW_FALSE;

  }

  while ((i < len) && NW_Str_Isdigit(scr_charat(s, i))) {

    i++;

  }

  end = i;

  if (start == end) {

    return NW_FALSE;

  }

  while ((i < len) && (scr_charat(s, i) <= 32) ) {

    i++;

  }

  if (i== len) {

    *consumeAll = NW_TRUE;

  }

  /* extract substring and convert to long */

  substr = scr_substr(s, start, end - start);

  if (substr == NULL)

    return NW_FALSE;

  wstr = str2ucs2(substr);

  free_str(substr);

  if (wstr == NULL)

    return NW_FALSE;

  status = NW_Str_CvtToInt32(wstr, &p, 10, res);

  NW_Mem_Free(wstr);

  if (status != KBrsrSuccess) {

    return NW_FALSE;

  }

  if (p != NULL) {

    return NW_TRUE;

  } else {

    return NW_FALSE;

  }

}

/*

<prefix><NW_Int32 >.<secondInt>e<exponent><postfix>

*/

/* needs more work to meet the specs */

NW_Bool str2float(str_t s, NW_Float32 * res, NW_Bool * consumeAll)

{

  NW_Int32 start = 0, len = str_len(s), end, i;

  NW_Ucs2 c;

  NW_Float64 intPart = 0.0;

  NW_Float64 fracPart = 0.0;

  NW_Float32 expPart = 1.0;

  NW_Int32   sign = 1;

  NW_Int32   expVal = 0;

  NW_Float64 res64;

  NW_ASSERT(s);

  NW_ASSERT(res);

  NW_ASSERT(consumeAll);

  *consumeAll = NW_FALSE;

  /* skipping white spaces */

  while ((start < len) && (scr_charat(s, start) <= 32)) {

    start++;

  }

  i = start;

  if (i == len) {

    return NW_FALSE;               /* reach the end of the string */

  }

  c = scr_charat(s, i);

  if ((c != '+') && (c != '-') && (c != '.') && !NW_Str_Isdigit(c)) {

    return NW_FALSE;

  }

  if (c != '.') {

    /* read NW_Int32  part */

    if (c == '-') {

      sign = -1;

    } else if (NW_Str_Isdigit(c)) {

      intPart = (NW_Float32)(c - '0');

    }

    i++;

    while ((i < len) && NW_Str_Isdigit(scr_charat(s, i))) {

      if (is_finite_float64(intPart)) {

        intPart = (intPart * 10) + (scr_charat(s, i) - '0');

      }

      i++;

    }

    if (is_finite_float64(intPart)) {

      intPart *= sign;

    } else {

      return NW_FALSE;

    }

  }

  if ((i < len) && (scr_charat(s, i) == '.')) {

    /* read fraction part */

    i++;

    expPart = 0.1f;

    while ((i < len) && NW_Str_Isdigit(scr_charat(s, i))) {

      /*lint -e{747} Significant prototype coercion*/

      if (! is_zero_float64(expPart)) {

        fracPart = fracPart + expPart*(scr_charat(s, i) - '0');

        expPart *= 0.1f;

      }

      i++;

    }

    fracPart *= sign;

  }

  if ((i < len) && ((scr_charat(s, i) == 'e') || (scr_charat(s, i) == 'E'))) {

    /* if we have xxx[e|E] we must have exponent of some kind */

    if (++i >= len) {

      return NW_FALSE;

    }

    c = scr_charat(s, i);

    /* exp must be e[+|-]nn */

    if ((c != '+') && (c != '-') && !NW_Str_Isdigit(c)) {

      return NW_FALSE;

    }

    i++;

    sign = 1;

    /* if exp is e[+|-] or e[+|-]xx where xx is not a number, error */

    if ((c == '+') || (c == '-')) {

      if ((i >= len) || !NW_Str_Isdigit(scr_charat(s, i))) {

        return NW_FALSE;

      } else if (c == '-') {

          sign = -1;

      }

    } else {

      expVal = c - '0';

    }

    /* Get exponent digits. */

    while ((i < len) && NW_Str_Isdigit(scr_charat(s, i))) {

      /* if we can't hold exponent we've got over/underflow */

      if ((expVal > NW_FLOAT32_MAX_EXP) && (sign > 0)) {

        return NW_FALSE; /* overflow */

      } else {

        /* if exponent is neg, spec says underflow -> 0, so */

        /* we need to eat all chars in exp, but want expVal to */

        /* remain a big, negative, number */

        if (expVal >= 0) {

          if (expVal < 2 * NW_FLOAT32_MAX_EXP) {

            expVal = (expVal * 10) + (scr_charat(s, i) - '0');

          }

        }

      }

      i++;

    }

    if (expVal > 0) {

      expVal *= sign;

    }

  }

  /* End exponent part. */

  end = i;

  /* explicit check for just sign char, i.e. '+' or '-' */

  if ( (start == end) ||

       ((start + 1 == end) && !NW_Str_Isdigit(scr_charat(s, start))) )

  {

    return NW_FALSE;

  }

  while ((i < len) && (scr_charat(s, i) <= 32)) {

    i++;

  }

  if (i == len) {

    *consumeAll = NW_TRUE;

  }

  /* The calculations will be done with doubles, so allow double

   * the exponents for the time being.

   */

  if (expVal < NW_FLOAT32_MIN_EXP * 2) {

    *res = 0.0f;

    return NW_TRUE;

  } else if (expVal > NW_FLOAT32_MAX_EXP * 2) {

    return NW_FALSE;

  } else {

    res64 = (intPart + fracPart)*NW_Math_powint64(10.0f, expVal);

    if (is_zero_float64(res64)) {

      *res = 0.0f;

      return NW_TRUE;

    } else if (is_finite_float64(res64)) {

      *res = (NW_Float32)res64;

      return NW_TRUE;

    } else {

      return NW_FALSE;

    }

  }

}

str_t int2str(NW_Int32 i)

{

  /* Note: largest formatted NW_Int32 is 11 chars

   * (sign plus 10 digits)

   */

  NW_Ucs2 buf[MAX_CHAR_GROUP_LEN];

  NW_Ucs2 fmt[8];

  NW_Uint32 len;

  NW_Str_StrcpyConst(fmt, "%d");

  len = Snprintf(buf, MAX_CHAR_GROUP_LEN, fmt, i);

  NW_ASSERT(len < MAX_CHAR_GROUP_LEN);

	/* To fix TI compiler warning */

	(void) len;

  return ucs22str(buf);

}

str_t float2str(NW_Float32 f)

{

  /* Note: largest formatted NW_Float32 is 13 chars

   * (sign plus 8 digits [24-bit mantissa] plus decimal point

   * plus 'E' plus exponent sign plus 2 digits) */

  NW_Ucs2 buf[MAX_CHAR_GROUP_LEN];

  NW_Ucs2 fmt[8];

  NW_Uint32 len;

  NW_Float64 d = f; /* we use double to match %g c.f. NW_Str_Sprintf */

  NW_Str_StrcpyConst(fmt, "%g");

  len = Snprintf(buf, MAX_CHAR_GROUP_LEN, fmt, d);

  NW_ASSERT(len < MAX_CHAR_GROUP_LEN);

	/* To fix TI compiler warning */

	(void) len;

  return ucs22str(buf);

}

str_t bool2str(NW_Bool b)

{

  NW_Ucs2 bool_str[8];

  if (b)

    NW_Str_StrcpyConst(bool_str, "true");

  else

    NW_Str_StrcpyConst(bool_str, "false");

  return ucs22str(bool_str);

}

/*

** VSWAP wmlscriptlib/string/format/f/10 wants a single precision float to

** end up with an arbitrary number of sig digs.  If value is initially

** specified as string, and it CAN be converted into a float, then just

** strip leading & trailing spaces, apply width and precision including of

** course rounding at the proper position. More appropriate, colorful, and

** unfriendly commentary on this decision would seem unprofessional,

** particularly in a source-code product.  AWalsh 23-Feb-01.

*/

NW_Bool ProcessFloatStr(NW_Ucs2 *tmp_buff, NW_Int32 buffLength,

                        NW_Int32 precision, val_t val)

{

  NW_Ucs2   *pEntire;

  NW_Ucs2   *pStart;

  NW_Ucs2   *pTemp;

  NW_Ucs2   *pDecimal = NULL;

  NW_Bool   hasSign = NW_FALSE;

  NW_Int32  numberLen;

  NW_Int32  fracLen;

  NW_Int32  intLen;

  NW_Int32  roundSpot;

  if (!IS_STR(val)) {

    return NW_FALSE;

  }

  /*

  ** subtract 1 from buffLength because we might need to add a character

  ** during rounding.

  */

  buffLength--;

  pEntire = pStart = str2ucs2(val.value.s);

  /* strip leading white space */

  while ( *pStart && NW_Str_Isspace(*pStart) ) {

    pStart++;

  }

  if ( !(*pStart) ) {

    NW_Str_Delete(pEntire);

    return NW_FALSE;

  }

  pTemp = pStart;

  /* check to make sure format is [+/-]ddd.ddd */

  if ( (*pTemp == WAE_URL_PLUS_CHAR) || (*pTemp == WAE_URL_DASH_CHAR) ) {

    pStart++;

    pTemp++;

    hasSign = NW_TRUE;

  }

  while ( *pTemp &&

          (NW_Str_Isdigit(*pTemp) || (*pTemp == WAE_URL_DOT_CHAR))  )

  {

    if (*pTemp == WAE_URL_DOT_CHAR) {

      /* two dots is not valid float representation */

      if (pDecimal != NULL) {

        NW_Str_Delete(pEntire);

        return NW_FALSE;

      }

      pDecimal = pTemp;

    }

    pTemp++;

  }

  /*

  ** if we're not at the end, and we've found something other than

  ** whitespace, then we don't have [+/-]ddd.ddd so we can't use our hack.

  ** Also, if the string we're trying to fudge is too long for the buffer,

  ** don't use the hack.

  */

  numberLen = NW_Str_Strlen(pStart) - NW_Str_Strlen(pTemp);

  if ( (*pTemp && !NW_Str_Isspace(*pTemp))

       || ( numberLen >= buffLength ) )

  {

    NW_Str_Delete(pEntire);

    return NW_FALSE;

  }

  /*

  ** now we've got the right format, starting at pStart, ending at pTemp,

  ** possibly containing pDecimal.  Examine precision to decide whether we need

  ** to add zeros, round and/or truncate.

  */

  if (precision == NO_PRECISION) {

    precision = NW_DEFAULT_FLOAT_PREC;

  }

  if (pDecimal != NULL) {

    /* don't count the '.' in fracLen or intLen */

    fracLen = NW_Str_Strlen(pDecimal) - NW_Str_Strlen(pTemp) - 1;

    intLen = numberLen - fracLen - 1;

  } else {

    fracLen = 0;

    intLen = numberLen;

  }

  /*

  ** if we need to pad, and it pushes us over the limit of buffLength then

  ** bail out on our hack.

  */

  if (numberLen - fracLen + precision >= buffLength) {

    NW_Str_Delete(pEntire);

    return NW_FALSE;

  }

  /*

  ** do rounding if necessary - note AWalsh is too lazy to apply the

  ** even/odd rule, so 5 rounds up.  Also note AWalsh is too lazy to worry

  ** about non-ascii character sets and assumes integer values for chars

  ** '0' + 1 = '1', '1' + 1 = '2' etc.

  */

  roundSpot = precision;

  if ( (precision < fracLen) && (pDecimal[roundSpot+1] > '4') ) {

    NW_ASSERT(pDecimal != NULL);

    while (pDecimal[roundSpot] == '9') {

      pDecimal[roundSpot] = '0';

      roundSpot--;

    }

    if (roundSpot == 0) {

      roundSpot = intLen;

      while ( (pStart[roundSpot] == '9') && (roundSpot >= 0) ){

        pStart[roundSpot] = '0';

        roundSpot--;

      }

      if (roundSpot >= 0) {

        pStart[roundSpot]++;