/FileExtraction/Java_unseen/dlitz_resin/modules/quercus/src/com/caucho/quercus/lib/string/StringUtility.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Nam Nguyen
 */

package com.caucho.quercus.lib.string;

import java.io.IOException;

import com.caucho.quercus.QuercusModuleException;
import com.caucho.quercus.env.ArrayValue;
import com.caucho.quercus.env.ArrayValueImpl;
import com.caucho.quercus.env.Env;
import com.caucho.quercus.env.NullValue;
import com.caucho.quercus.env.Post;
import com.caucho.quercus.env.Value;
import com.caucho.quercus.lib.ArrayModule;
import com.caucho.util.L10N;
import com.caucho.vfs.ByteToChar;

public class StringUtility
{
  private static final L10N L = new L10N(StringModule.class);

  public static Value parseStr(Env env,
                               CharSequence str,
                               ArrayValue result,
                               boolean isRef,
                               String encoding)
  {
    return parseStr(env, str, result, isRef, encoding,
                    env.getIniBoolean("magic_quotes_gpc"),
                    Env.DEFAULT_QUERY_SEPARATOR_MAP);
  }
  
  public static Value parseStr(Env env,
                               CharSequence str,
                               ArrayValue result,
                               boolean isRef,
                               String encoding,
                               boolean isMagicQuotes,
                               int []querySeparatorMap)
  {
    try {
      ByteToChar byteToChar = env.getByteToChar();
      
      if (encoding != null)
        byteToChar.setEncoding(encoding);
      
      int len = str.length();

      for (int i = 0; i < len; i++) {
        int ch = 0;
        byteToChar.clear();

        for (;
             i < len && isSeparator(querySeparatorMap, ch = str.charAt(i));
             i++) {
        }
      
        for (; i < len && (ch = str.charAt(i)) != '='
             && ! isSeparator(querySeparatorMap, ch); i++) {
          i = addQueryChar(byteToChar, str, len, i, ch);
        }

        String key = byteToChar.getConvertedString();

        byteToChar.clear();

        String value;
        if (ch == '=') {
          for (i++; i < len
               && ! isSeparator(querySeparatorMap, (ch = str.charAt(i))); i++) {
            i = addQueryChar(byteToChar, str, len, i, ch);
          }

          value = byteToChar.getConvertedString();
        }
        else
          value = "";

        if (isRef) {
          Post.addFormValue(env, result, key,
                            new String[] { value }, isMagicQuotes);
        } else {
          // If key is an exsiting array, then append
          // this value to existing array
          // Only use extract(EXTR_OVERWRITE) on non-array variables or
          // non-existing arrays
          int openBracketIndex = key.indexOf('[');
          int closeBracketIndex = key.indexOf(']');
          if (openBracketIndex > 0) {
            String arrayName = key.substring(0, openBracketIndex);
            arrayName = arrayName.replaceAll("\\.", "_");
            
            Value v = env.getVar(arrayName).getRawValue();
            if (v instanceof ArrayValue) {
              //Check to make sure valid string (ie: foo[...])
              if (closeBracketIndex < 0) {
                env.warning(L.l("invalid array {0}", key));
                return NullValue.NULL;
              }

              if (closeBracketIndex > openBracketIndex + 1) {
                String index = key
                    .substring(key.indexOf('[') + 1, key.indexOf(']'));
                v.put(env.createString(index), env.createString(value));
              } else {
                v.put(env.createString(value));
              }
            } else {
              Post.addFormValue(env, result, key,
                                new String[] { value }, isMagicQuotes);
            }
          } else {
            Post.addFormValue(env, result, key,
                              new String[] { value }, isMagicQuotes);
          }
        }
      }

      if (! isRef) {
        ArrayModule.extract(env, result,
                            ArrayModule.EXTR_OVERWRITE,
                            null);
      }

      return NullValue.NULL;
    } catch (IOException e) {
      throw new QuercusModuleException(e);
    }
  }
  
  private static boolean isSeparator(int []sep, int ch)
  {
    return (ch < sep.length && sep[ch] > 0);
  }

  protected static int addQueryChar(ByteToChar byteToChar,
                                    CharSequence str,
                                    int len,
                                    int i,
                                    int ch)
    throws IOException
  {
    if (str == null)
      str = "";

    switch (ch) {
    case '+':
      byteToChar.addChar(' ');
      return i;

    case '%':
      if (i + 2 < len) {
        int d1 = StringModule.hexToDigit(str.charAt(i + 1));
        int d2 = StringModule.hexToDigit(str.charAt(i + 2));

        // XXX: d1 and d2 may be -1 if not valid hex chars
        byteToChar.addByte(d1 * 16 + d2);

        return i + 2;
      }
      else {
        byteToChar.addByte((byte) ch);
        return i;
      }

    default:
      byteToChar.addByte((byte) ch);
      return i;
    }
  }

  public static void addQueryValue(Env env, ArrayValue array,
                                   String key, String valueStr)
  {
    if (key == null)
      key = "";
    
    if (valueStr == null)
      valueStr = "";
    
    int p;

    Value value = env.createString(valueStr);

    if ((p = key.indexOf('[')) > 0 && key.endsWith("]")) {
      String index = key.substring(p + 1, key.length() - 1);
      key = key.substring(0, p);

      Value keyValue = env.createString(key);

      Value part;

      if (array != null)
        part = array.get(keyValue);
      else
        part = env.getVar(key);

      if (! part.isArray())
        part = new ArrayValueImpl();

      if (index.equals(""))
        part.put(value);
      else
        part.put(env.createString(index), value);

      if (array != null)
        array.put(keyValue, part);
      else
        env.setVar(key, part);
    }
    else {
      if (array != null)
        array.put(env.createString(key), value);
      else
        env.setVar(key, value);
    }
  }
}
