/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*- * * The contents of this file are subject to the Netscape Public * License Version 1.1 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.mozilla.org/NPL/ * * Software distributed under the License is distributed on an "AS * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or * implied. See the License for the specific language governing * rights and limitations under the License. * * The Original Code is Rhino code, released * May 6, 1998. * * The Initial Developer of the Original Code is Netscape * Communications Corporation.  Portions created by Netscape are * Copyright (C) 1997-1999 Netscape Communications Corporation. All * Rights Reserved. * * Contributor(s): * * Alternatively, the contents of this file may be used under the * terms of the GNU Public License (the "GPL"), in which case the * provisions of the GPL are applicable instead of those above. * If you wish to allow use of your version of this file only * under the terms of the GPL and not to allow others to use your * version of this file under the NPL, indicate your decision by * deleting the provisions above and replace them with the notice * and other provisions required by the GPL.  If you do not delete * the provisions above, a recipient may use your version of this * file under either the NPL or the GPL. */package org.mozilla.javascript.regexp;import org.mozilla.javascript.*;/** * */public class RegExpImpl implements RegExpProxy {    public boolean isRegExp(Scriptable obj) {        return obj instanceof NativeRegExp;    }    public Object compileRegExp(Context cx, String source, String flags)    {        return NativeRegExp.compileRE(source, flags, false);    }    public Scriptable wrapRegExp(Context cx, Scriptable scope,                                 Object compiled)    {        return new NativeRegExp(scope, compiled);    }    public Object action(Context cx, Scriptable scope,                         Scriptable thisObj, Object[] args,                         int actionType)    {        GlobData data = new GlobData();        data.mode = actionType;        switch (actionType) {          case RA_MATCH:            {                Object rval;                data.optarg = 1;                rval = matchOrReplace(cx, scope, thisObj, args,                                      this, data, false);                return data.arrayobj == null ? rval : data.arrayobj;            }          case RA_SEARCH:            data.optarg = 1;            return matchOrReplace(cx, scope, thisObj, args,                                  this, data, false);          case RA_REPLACE:            {                Object arg1 = args.length < 2 ? Undefined.instance : args[1];                String repstr = null;                Function lambda = null;                if (arg1 instanceof Function) {                    lambda = (Function) arg1;                } else {                    repstr = ScriptRuntime.toString(arg1);                }                data.optarg = 2;                data.lambda = lambda;                data.repstr = repstr;                data.dollar = repstr == null ? -1 : repstr.indexOf('$');                data.charBuf = null;                data.leftIndex = 0;                Object val = matchOrReplace(cx, scope, thisObj, args,                                            this, data, true);                SubString rc = this.rightContext;                if (data.charBuf == null) {                    if (data.global || val == null                        || !val.equals(Boolean.TRUE))                    {                        /* Didn't match even once. */                        return data.str;                    }                    SubString lc = this.leftContext;                    replace_glob(data, cx, scope, this, lc.index, lc.length);                }                data.charBuf.append(rc.charArray, rc.index, rc.length);                return data.charBuf.toString();            }          default:            throw Kit.codeBug();        }    }    /**     * Analog of C match_or_replace.     */    private static Object matchOrReplace(Context cx, Scriptable scope,                                         Scriptable thisObj, Object[] args,                                         RegExpImpl reImpl,                                         GlobData data, boolean forceFlat)    {        NativeRegExp re;        String str = ScriptRuntime.toString(thisObj);        data.str = str;        Scriptable topScope = ScriptableObject.getTopLevelScope(scope);        if (args.length == 0) {            Object compiled = NativeRegExp.compileRE("", "", false);            re = new NativeRegExp(topScope, compiled);        } else if (args[0] instanceof NativeRegExp) {            re = (NativeRegExp) args[0];        } else {            String src = ScriptRuntime.toString(args[0]);            String opt;            if (data.optarg < args.length) {                args[0] = src;                opt = ScriptRuntime.toString(args[data.optarg]);            } else {                opt = null;            }            Object compiled = NativeRegExp.compileRE(src, opt, forceFlat);            re = new NativeRegExp(topScope, compiled);        }        data.regexp = re;        data.global = (re.getFlags() & NativeRegExp.JSREG_GLOB) != 0;        int[] indexp = { 0 };        Object result = null;        if (data.mode == RA_SEARCH) {            result = re.executeRegExp(cx, scope, reImpl,                                      str, indexp, NativeRegExp.TEST);            if (result != null && result.equals(Boolean.TRUE))                result = new Integer(reImpl.leftContext.length);            else                result = new Integer(-1);        } else if (data.global) {            re.lastIndex = 0;            for (int count = 0; indexp[0] <= str.length(); count++) {                result = re.executeRegExp(cx, scope, reImpl,                                          str, indexp, NativeRegExp.TEST);                if (result == null || !result.equals(Boolean.TRUE))                    break;                if (data.mode == RA_MATCH) {                    match_glob(data, cx, scope, count, reImpl);                } else {                    if (data.mode != RA_REPLACE) Kit.codeBug();                    SubString lastMatch = reImpl.lastMatch;                    int leftIndex = data.leftIndex;                    int leftlen = lastMatch.index - leftIndex;                    data.leftIndex = lastMatch.index + lastMatch.length;                    replace_glob(data, cx, scope, reImpl, leftIndex, leftlen);                }                if (reImpl.lastMatch.length == 0) {                    if (indexp[0] == str.length())                        break;                    indexp[0]++;                }            }        } else {            result = re.executeRegExp(cx, scope, reImpl, str, indexp,                                      ((data.mode == RA_REPLACE)                                       ? NativeRegExp.TEST                                       : NativeRegExp.MATCH));        }        return result;    }    public int find_split(Context cx, Scriptable scope, String target,                          String separator, Scriptable reObj,                          int[] ip, int[] matchlen,                          boolean[] matched, String[][] parensp)    {        int i = ip[0];        int length = target.length();        int result;        int version = cx.getLanguageVersion();        NativeRegExp re = (NativeRegExp) reObj;        again:        while (true) {  // imitating C label            /* JS1.2 deviated from Perl by never matching at end of string. */            int ipsave = ip[0]; // reuse ip to save object creation            ip[0] = i;            Object ret = re.executeRegExp(cx, scope, this, target, ip,                                          NativeRegExp.TEST);            if (ret != Boolean.TRUE) {                // Mismatch: ensure our caller advances i past end of string.                ip[0] = ipsave;                matchlen[0] = 1;                matched[0] = false;                return length;            }            i = ip[0];            ip[0] = ipsave;            matched[0] = true;            SubString sep = this.lastMatch;            matchlen[0] = sep.length;            if (matchlen[0] == 0) {                /*                 * Empty string match: never split on an empty                 * match at the start of a find_split cycle.  Same                 * rule as for an empty global match in                 * match_or_replace.                 */                if (i == ip[0]) {                    /*                     * "Bump-along" to avoid sticking at an empty                     * match, but don't bump past end of string --                     * our caller must do that by adding                     * sep->length to our return value.                     */                    if (i == length) {                        if (version == Context.VERSION_1_2) {                            matchlen[0] = 1;                            result = i;                        }                        else                            result = -1;                        break;                    }                    i++;                    continue again; // imitating C goto                }            }            // PR_ASSERT((size_t)i >= sep->length);            result = i - matchlen[0];            break;        }        int size = (parens == null) ? 0 : parens.length;        parensp[0] = new String[size];        for (int num = 0; num < size; num++) {            SubString parsub = getParenSubString(num);            parensp[0][num] = parsub.toString();        }        return result;    }    /**