Changeset 798 in webkit for trunk/JavaScriptCore/kjs/regexp_object.cpp

Timestamp:

Mar 21, 2002, 4:31:57 PM (23 years ago)

Author:

mjs

Message:

Merged changes from LABYRINTH_KDE_3_MERGE branch.

File:

• trunk/JavaScriptCore/kjs/regexp_object.cpp (modified) (3 diffs)

trunk/JavaScriptCore/kjs/regexp_object.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -16 +17 @@
  *  License along with this library; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ *  $Id$
  */
 
 #include <stdio.h>
 
-#include "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "operations.h"
-#include "types.h"
 #include "internal.h"
 #include "regexp.h"
 #include "regexp_object.h"
+#include "error_object.h"
 
 using namespace KJS;
 
-RegExpObject::RegExpObject(const Object& funcProto, const Object &regProto)
-    : ConstructorImp(funcProto, 2)
-{
+// ------------------------------ RegExpPrototypeImp ---------------------------
+
+// ECMA 15.9.4
+
+RegExpPrototypeImp::RegExpPrototypeImp(ExecState *exec,
+                                       ObjectPrototypeImp *objProto,
+                                       FunctionPrototypeImp *funcProto)
+  : ObjectImp(Object(objProto))
+{
+  Value protect(this);
+  setInternalValue(String(""));
+
+  // The constructor will be added later in RegExpObject's constructor (?)
+
+  put(exec, "exec",     Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::Exec,     0)), DontEnum);
+  put(exec, "test",     Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::Test,     0)), DontEnum);
+  put(exec, "toString", Object(new RegExpProtoFuncImp(exec,funcProto,RegExpProtoFuncImp::ToString, 0)), DontEnum);
+}
+
+// ------------------------------ RegExpProtoFuncImp ---------------------------
+
+RegExpProtoFuncImp::RegExpProtoFuncImp(ExecState *exec,
+                                       FunctionPrototypeImp *funcProto, int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+bool RegExpProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+Value RegExpProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  if (!thisObj.inherits(&RegExpImp::info)) {
+    Object err = Error::create(exec,TypeError);
+    exec->setException(err);
+    return err;
+  }
+
+  RegExpImp *reimp = static_cast<RegExpImp*>(thisObj.imp());
+  RegExp *re = reimp->regExp();
+  String s;
+  UString str;
+  switch (id) {
+  case Exec:      // 15.10.6.2
+  case Test:
+  {
+    s = args[0].toString(exec);
+    int length = s.value().size();
+    Value lastIndex = thisObj.get(exec,"lastIndex");
+    int i = lastIndex.isNull() ? 0 : lastIndex.toInt32(exec);
+    bool globalFlag = thisObj.get(exec,"global").toBoolean(exec);
+    if (!globalFlag)
+      i = 0;
+    if (i < 0 || i > length) {
+      thisObj.put(exec,"lastIndex", Number(0), DontDelete | DontEnum);
+      return Null();
+    }
+    RegExpObjectImp* regExpObj = static_cast<RegExpObjectImp*>(exec->interpreter()->builtinRegExp().imp());
+    int **ovector = regExpObj->registerRegexp( re, s.value() );
+
+    str = re->match(s.value(), i, 0L, ovector);
+
+    if (id == Test)
+      return Boolean(!str.isNull());
+
+    if (str.isNull()) // no match
+    {
+      if (globalFlag)
+        thisObj.put(exec,"lastIndex",Number(0), DontDelete | DontEnum);
+      return Null();
+    }
+    else // success
+    {
+      if (globalFlag)
+        thisObj.put(exec,"lastIndex",Number( (*ovector)[1] ), DontDelete | DontEnum);
+      return regExpObj->arrayOfMatches(exec,str);
+    }
+  }
+  break;
+  case ToString:
+    s = thisObj.get(exec,"source").toString(exec);
+    str = "/";
+    str += s.value();
+    str += "/";
+    // TODO append the flags
+    return String(str);
+  }
+
+  return Undefined();
+}
+
+// ------------------------------ RegExpImp ------------------------------------
+
+const ClassInfo RegExpImp::info = {"RegExp", 0, 0, 0};
+
+RegExpImp::RegExpImp(RegExpPrototypeImp *regexpProto)
+  : ObjectImp(Object(regexpProto)), reg(0L)
+{
+}
+
+RegExpImp::~RegExpImp()
+{
+  delete reg;
+}
+
+// ------------------------------ RegExpObjectImp ------------------------------
+
+RegExpObjectImp::RegExpObjectImp(ExecState *exec,
+                                 RegExpPrototypeImp *regProto,
+                                 FunctionPrototypeImp *funcProto)
+  : InternalFunctionImp(funcProto), lastOvector(0L), lastNrSubPatterns(0)
+{
+  Value protect(this);
   // ECMA 15.10.5.1 RegExp.prototype
-  setPrototypeProperty(regProto);
-}
-
-// ECMA 15.9.2
-Completion RegExpObject::execute(const List &)
-{
-  return Completion(ReturnValue, Undefined());
-}
-
-// ECMA 15.9.3
-Object RegExpObject::construct(const List &args)
-{
-  /* TODO: regexp arguments */
-  String p = args[0].toString();
-  String f = args[1].toString();
+  put(exec,"prototype", Object(regProto), DontEnum|DontDelete|ReadOnly);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(2), ReadOnly|DontDelete|DontEnum);
+}
+
+RegExpObjectImp::~RegExpObjectImp()
+{
+  if (lastOvector)
+    delete [] lastOvector;
+}
+
+int **RegExpObjectImp::registerRegexp( const RegExp* re, const UString& s )
+{
+  lastString = s;
+  if (lastOvector)
+    delete [] lastOvector;
+  lastOvector = 0;
+  lastNrSubPatterns = re->subPatterns();
+  return &lastOvector;
+}
+
+Value RegExpObjectImp::arrayOfMatches(ExecState *exec, const UString &result) const
+{
+  List list;
+  // The returned array contains 'result' as first item, followed by the list of matches
+  list.append(String(result));
+  if ( lastOvector )
+    for ( uint i = 1 ; i < lastNrSubPatterns + 1 ; ++i )
+    {
+      UString substring = lastString.substr( lastOvector[2*i], lastOvector[2*i+1] - lastOvector[2*i] );
+      list.append(String(substring));
+    }
+  return exec->interpreter()->builtinArray().construct(exec, list);
+}
+
+Value RegExpObjectImp::get(ExecState *, const UString &p) const
+{
+  if (p[0] == '$' && lastOvector)
+  {
+    bool ok;
+    unsigned long i = p.substr(1).toULong(&ok);
+    if (ok)
+    {
+      if (i < lastNrSubPatterns + 1)
+      {
+        UString substring = lastString.substr( lastOvector[2*i], lastOvector[2*i+1] - lastOvector[2*i] );
+        return String(substring);
+      }
+      return String("");
+    }
+  }
+  return Undefined();
+}
+
+bool RegExpObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 15.10.4
+Object RegExpObjectImp::construct(ExecState *exec, const List &args)
+{
+  String p = args[0].toString(exec);
+  String f = args[1].toString(exec);
   UString flags = f.value();
 
-  RegExpImp *dat = new RegExpImp();
+  RegExpPrototypeImp *proto = static_cast<RegExpPrototypeImp*>(exec->interpreter()->builtinRegExpPrototype().imp());
+  RegExpImp *dat = new RegExpImp(proto);
   Object obj(dat); // protect from GC
 
@@ -56 +227 @@
   bool ignoreCase = (flags.find("i") >= 0);
   bool multiline = (flags.find("m") >= 0);
-  /* TODO: throw an error on invalid flags */
-
-  dat->put("global", Boolean(global));
-  dat->put("ignoreCase", Boolean(ignoreCase));
-  dat->put("multiline", Boolean(multiline));
-
-  dat->put("source", String(p.value()));
-  dat->put("lastIndex", 0, DontDelete | DontEnum);
-
-  dat->setRegExp(new RegExp(p.value() /* TODO flags */));
-  obj.setClass(RegExpClass);
-  obj.setPrototype(Global::current().get("[[RegExp.prototype]]"));
+  // TODO: throw a syntax error on invalid flags
+
+  dat->put(exec, "global", Boolean(global));
+  dat->put(exec, "ignoreCase", Boolean(ignoreCase));
+  dat->put(exec, "multiline", Boolean(multiline));
+
+  dat->put(exec, "source", String(p.value()));
+  dat->put(exec, "lastIndex", Number(0), DontDelete | DontEnum);
+
+  int reflags = RegExp::None;
+  if (global)
+      reflags |= RegExp::Global;
+  if (ignoreCase)
+      reflags |= RegExp::IgnoreCase;
+  if (multiline)
+      reflags |= RegExp::Multiline;
+  dat->setRegExp(new RegExp(p.value(), reflags));
 
   return obj;
 }
 
-// ECMA 15.9.4
-RegExpPrototype::RegExpPrototype(const Object& proto)
-  : ObjectImp(RegExpClass, String(""), proto)
-{
-  // The constructor will be added later in RegExpObject's constructor
-}
-
-KJSO RegExpPrototype::get(const UString &p) const
-{
-  int id = -1;
-  if (p == "exec")
-    id = RegExpProtoFunc::Exec;
-  else if (p == "test")
-    id = RegExpProtoFunc::Test;
-  else if (p == "toString")
-    id = RegExpProtoFunc::ToString;
-
-  if (id >= 0)
-    return Function(new RegExpProtoFunc(id));
-  else
-    return Imp::get(p);
-}
-
-Completion RegExpProtoFunc::execute(const List &args)
-{
-  KJSO result;
-
-  Object thisObj = Object::dynamicCast(thisValue());
-
-  if (thisObj.getClass() != RegExpClass) {
-    result = Error::create(TypeError);
-    return Completion(ReturnValue, result);
-  }
-
-  RegExp *re = static_cast<RegExpImp*>(thisObj.imp())->regExp();
-  String s;
-  KJSO lastIndex, tmp;
-  UString str;
-  int length, i;
-  switch (id) {
-  case Exec:
-  case Test:
-    s = args[0].toString();
-    length = s.value().size();
-    lastIndex = thisObj.get("lastIndex");
-    i = lastIndex.toInt32();
-    tmp = thisObj.get("global");
-    if (tmp.toBoolean().value() == false)
-      i = 0;
-    if (i < 0 || i > length) {
-      thisObj.put("lastIndex", 0);
-      result = Null();
-      break;
-    }
-    str = re->match(s.value(), i);
-    if (id == Test) {
-      result = Boolean(str.size() != 0);
-      break;
-    }
-    /* TODO complete */
-    result = String(str);
-    break;
-  case ToString:
-    s = thisObj.get("source").toString();
-    str = "/";
-    str += s.value();
-    str += "/";
-    result = String(str);
-    break;
-  }
-
-  return Completion(ReturnValue, result);
-}
+bool RegExpObjectImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.10.3
+Value RegExpObjectImp::call(ExecState */*exec*/, Object &/*thisObj*/, const List &/*args*/)
+{
+  // TODO: implement constructor
+  return Undefined();
+}