Changeset 798 in webkit for trunk/JavaScriptCore

Timestamp:

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

Author:

mjs

Message:

Merged changes from LABYRINTH_KDE_3_MERGE branch.

Location:

trunk/JavaScriptCore/kjs

Files:

• Makefile.am (modified) (5 diffs)
• array_object.cpp (modified) (2 diffs)
• array_object.h (modified) (4 diffs)
• bool_object.cpp (modified) (2 diffs)
• bool_object.h (modified) (3 diffs)
• collector.cpp (modified) (13 diffs)
• collector.h (modified) (5 diffs)
• create_hash_table (added)
• date_object.cpp (modified) (5 diffs)
• date_object.h (modified) (3 diffs)
• debugger.cpp (modified) (3 diffs)
• debugger.h (modified) (3 diffs)
• error_object.cpp (modified) (2 diffs)
• error_object.h (modified) (3 diffs)
• function.cpp (modified) (6 diffs)
• function.h (modified) (3 diffs)
• function_object.cpp (modified) (4 diffs)
• function_object.h (modified) (3 diffs)
• global_object.cpp (deleted)
• grammar.y (modified) (7 diffs)
• internal.cpp (modified) (6 diffs)
• internal.h (modified) (6 diffs)
• interpreter.cpp (added)
• interpreter.h (added)
• keywords.table (added)
• kjs.cpp (deleted)
• kjs.h (deleted)
• lexer.cpp (modified) (18 diffs)
• lexer.h (modified) (6 diffs)
• lexer.lut.h (modified) (1 diff)
• lookup.cpp (modified) (6 diffs)
• lookup.h (modified) (4 diffs)
• math_object.cpp (modified) (5 diffs)
• math_object.h (modified) (3 diffs)
• math_object.lut.h (modified) (1 diff)
• nodes.cpp (modified) (24 diffs)
• nodes.h (modified) (75 diffs)
• number_object.cpp (modified) (2 diffs)
• number_object.h (modified) (3 diffs)
• object.cpp (modified) (2 diffs)
• object.h (modified) (4 diffs)
• object_object.cpp (modified) (3 diffs)
• object_object.h (modified) (3 diffs)
• operations.cpp (modified) (9 diffs)
• operations.h (modified) (7 diffs)
• property_map.cpp (added)
• property_map.h (added)
• regexp.cpp (modified) (4 diffs)
• regexp.h (modified) (4 diffs)
• regexp_object.cpp (modified) (3 diffs)
• regexp_object.h (modified) (4 diffs)
• string_object.cpp (modified) (4 diffs)
• string_object.h (modified) (4 diffs)
• testkjs.cpp (modified) (3 diffs)
• types.cpp (modified) (3 diffs)
• types.h (modified) (9 diffs)
• ustring.cpp (modified) (16 diffs)
• ustring.h (modified) (9 diffs)
• value.cpp (added)
• value.h (added)

trunk/JavaScriptCore/kjs/Makefile.am

@@ -4 +4 @@
 libkjs_o_LDFLAGS = -Wl,-r -nostdlib
 libkjs_o_AR = $(OBJCXXLD) $(AM_OBJCXXFLAGS) $(OBJCXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) $(libkjs_o_LDFLAGS) -o
+
+INCLUDES = $(KWQ_INCLUDES)
 
 libkjs_o_SOURCES = \
@@ -22 +24 @@
         function_object.cpp \
         function_object.h \
-        global_object.cpp \
         grammar.cpp \
         grammar.h \
         internal.cpp \
         internal.h \
-        kjs.cpp \
-        kjs.h \
+        interpreter.cpp \
+        interpreter.h \
         lexer.cpp \
         lexer.h \
@@ -47 +48 @@
         operations.cpp \
         operations.h \
+        property_map.cpp \
+        property_map.h \
         regexp.cpp \
         regexp.h \
@@ -57 +60 @@
         ustring.cpp \
         ustring.h \
+        value.cpp \
+        value.h \
         $(NULL)
 
@@ -76 +81 @@
         touch ./grammar-stamp
 
-BUILT_SOURCES = $(GRAMMAR_FILES) grammar-stamp
+LUT_FILES = math_object.lut.h lexer.lut.h array_object.lut.h date_object.lut.h string_object.lut.h number_object.lut.h
+
+lexer.lut.h: keywords.table
+        ./create_hash_table keywords.table -i > lexer.lut.h;
+
+array_object.lut.h: array_object.cpp
+        ./create_hash_table array_object.cpp -i > array_object.lut.h
+
+math_object.lut.h: math_object.cpp
+        ./create_hash_table math_object.cpp -i > math_object.lut.h
+
+date_object.lut.h: date_object.cpp
+        ./create_hash_table date_object.cpp -i > date_object.lut.h
+
+number_object.lut.h: number_object.cpp
+        ./create_hash_table number_object.cpp -i > number_object.lut.h
+
+string_object.lut.h: string_object.cpp
+        ./create_hash_table string_object.cpp -i > string_object.lut.h
+
+
+
+BUILT_SOURCES = $(GRAMMAR_FILES) $(LUT_FILES) grammar-stamp
 
 CLEANFILES = $(BUILT_SOURCES)

trunk/JavaScriptCore/kjs/array_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
+ *
  */
 
-#include "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "operations.h"
-#include "types.h"
 #include "array_object.h"
+#include "internal.h"
+#include "error_object.h"
+
+#include "array_object.lut.h"
+
 #include <stdio.h>
+#include <assert.h>
 
 using namespace KJS;
 
-ArrayObject::ArrayObject(const Object &funcProto,
-                         const Object &arrayProto)
-    : ConstructorImp(funcProto, 1)
-{
+// ------------------------------ ArrayInstanceImp -----------------------------
+
+const ClassInfo ArrayInstanceImp::info = {"Array", 0, 0, 0};
+
+ArrayInstanceImp::ArrayInstanceImp(const Object &proto)
+  : ObjectImp(proto)
+{
+}
+
+// Special implementation of [[Put]] - see ECMA 15.4.5.1
+void ArrayInstanceImp::put(ExecState *exec, const UString &propertyName, const Value &value, int attr)
+{
+  if ((attr == None || attr == DontDelete) && !canPut(exec,propertyName))
+    return;
+
+  if (hasProperty(exec,propertyName)) {
+    if (propertyName == "length") {
+      Value len = get(exec,"length");
+      unsigned int oldLen = len.toUInt32(exec);
+      unsigned int newLen = value.toUInt32(exec);
+      // shrink array
+      for (unsigned int u = newLen; u < oldLen; u++) {
+        UString p = UString::from(u);
+        if (hasProperty(exec, p, false))
+          deleteProperty(exec, p);
+      }
+      ObjectImp::put(exec, "length", Number(newLen), DontEnum | DontDelete);
+      return;
+    }
+    //    put(p, v);
+  } //  } else
+    ObjectImp::put(exec, propertyName, value, attr);
+
+  // array index ?
+  unsigned int idx;
+  if (!sscanf(propertyName.cstring().c_str(), "%u", &idx)) /* TODO */
+    return;
+
+  // do we need to update/create the length property ?
+  if (hasProperty(exec, "length", false)) {
+    Value len = get(exec, "length");
+    if (idx < len.toUInt32(exec))
+      return;
+  }
+
+  ObjectImp::put(exec, "length", Number(idx+1), DontDelete | DontEnum);
+}
+
+void ArrayInstanceImp::putDirect(ExecState *exec, const UString &propertyName, const Value &value, int attr)
+{
+  ObjectImp::put(exec,propertyName,value,attr);
+}
+// ------------------------------ ArrayPrototypeImp ----------------------------
+
+const ClassInfo ArrayPrototypeImp::info = {"Array", &ArrayInstanceImp::info, &arrayTable, 0};
+
+/* Source for array_object.lut.h
+@begin arrayTable 13
+  toString       ArrayProtoFuncImp::ToString       DontEnum|Function 0
+  toLocaleString ArrayProtoFuncImp::ToLocaleString DontEnum|Function 0
+  concat         ArrayProtoFuncImp::Concat         DontEnum|Function 1
+  join           ArrayProtoFuncImp::Join           DontEnum|Function 1
+  pop            ArrayProtoFuncImp::Pop            DontEnum|Function 0
+  push           ArrayProtoFuncImp::Push           DontEnum|Function 1
+  reverse        ArrayProtoFuncImp::Reverse        DontEnum|Function 0
+  shift          ArrayProtoFuncImp::Shift          DontEnum|Function 0
+  slice          ArrayProtoFuncImp::Slice          DontEnum|Function 2
+  sort           ArrayProtoFuncImp::Sort           DontEnum|Function 1
+  splice         ArrayProtoFuncImp::Splice         DontEnum|Function 2
+  unshift        ArrayProtoFuncImp::UnShift        DontEnum|Function 1
+@end
+*/
+
+// ECMA 15.4.4
+ArrayPrototypeImp::ArrayPrototypeImp(ExecState *exec,
+                                     ObjectPrototypeImp *objProto)
+  : ArrayInstanceImp(Object(objProto))
+{
+  Value protect(this);
+  setInternalValue(Null());
+
+  // The constructor will be added later, by InterpreterImp, once ArrayObjectImp has been constructed.
+  put(exec,"length", Number(0), DontEnum | DontDelete);
+}
+
+Value ArrayPrototypeImp::get(ExecState *exec, const UString &propertyName) const
+{
+  //fprintf( stderr, "ArrayPrototypeImp::get(%s)\n", propertyName.ascii() );
+  return lookupGetFunction<ArrayProtoFuncImp, ArrayInstanceImp>( exec, propertyName, &arrayTable, this );
+}
+
+// ------------------------------ ArrayProtoFuncImp ----------------------------
+
+ArrayProtoFuncImp::ArrayProtoFuncImp(ExecState *exec, int i, int len)
+  : InternalFunctionImp(
+    static_cast<FunctionPrototypeImp*>(exec->interpreter()->builtinFunctionPrototype().imp())
+    ), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+bool ArrayProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.4.4
+Value ArrayProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  unsigned int length = thisObj.get(exec,"length").toUInt32(exec);
+
+  Value result;
+  switch (id) {
+  case ToLocaleString:
+    // TODO  - see 15.4.4.3
+    // fall through
+  case ToString:
+
+    if (!thisObj.inherits(&ArrayInstanceImp::info)) {
+      Object err = Error::create(exec,TypeError);
+      exec->setException(err);
+      return err;
+    }
+
+    // fall through
+
+  case Join: {
+    UString separator = ",";
+    UString str = "";
+
+    if (args.size() > 0)
+      separator = args[0].toString(exec);
+    for (unsigned int k = 0; k < length; k++) {
+      if (k >= 1)
+        str += separator;
+      Value element = thisObj.get(exec,UString::from(k));
+      if (element.type() != UndefinedType && element.type() != NullType)
+        str += element.toString(exec);
+    }
+    result = String(str);
+    break;
+  }
+  case Concat: {
+    Object arr = Object::dynamicCast(exec->interpreter()->builtinArray().construct(exec,List::empty()));
+    int n = 0;
+    Value curArg = thisObj;
+    Object curObj = Object::dynamicCast(thisObj);
+    ListIterator it = args.begin();
+    for (;;) {
+      if (curArg.type() == ObjectType &&
+          curObj.inherits(&ArrayInstanceImp::info)) {
+        unsigned int k = 0;
+        if (n > 0)
+          length = curObj.get(exec,"length").toUInt32(exec);
+        while (k < length) {
+          UString p = UString::from(k);
+          if (curObj.hasProperty(exec,p))
+            arr.put(exec,UString::from(n), curObj.get(exec,p));
+          n++;
+          k++;
+        }
+      } else {
+        arr.put(exec,UString::from(n), curArg);
+        n++;
+      }
+      if (it == args.end())
+        break;
+      curArg = *it;
+      curObj = Object::dynamicCast(it++); // may be 0
+    }
+    arr.put(exec,"length", Number(n), DontEnum | DontDelete);
+
+    result = arr;
+    break;
+  }
+  case Pop:{
+
+    if (length == 0) {
+      thisObj.put(exec, "length", Number(length), DontEnum | DontDelete);
+      result = Undefined();
+    } else {
+      UString str = UString::from(length - 1);
+      result = thisObj.get(exec,str);
+      thisObj.deleteProperty(exec, str);
+      thisObj.put(exec, "length", Number(length - 1), DontEnum | DontDelete);
+    }
+    break;
+  }
+  case Push: {
+    for (int n = 0; n < args.size(); n++)
+      thisObj.put(exec,UString::from(length + n), args[n]);
+    length += args.size();
+    thisObj.put(exec,"length", Number(length), DontEnum | DontDelete);
+    result = Number(length);
+    break;
+  }
+  case Reverse: {
+
+    unsigned int middle = length / 2;
+
+    for (unsigned int k = 0; k < middle; k++) {
+      UString str = UString::from(k);
+      UString str2 = UString::from(length - k - 1);
+      Value obj = thisObj.get(exec,str);
+      Value obj2 = thisObj.get(exec,str2);
+      if (thisObj.hasProperty(exec,str2)) {
+        if (thisObj.hasProperty(exec,str)) {
+          thisObj.put(exec, str, obj2);
+          thisObj.put(exec, str2, obj);
+        } else {
+          thisObj.put(exec, str, obj2);
+          thisObj.deleteProperty(exec, str2);
+        }
+      } else {
+        if (thisObj.hasProperty(exec, str)) {
+          thisObj.deleteProperty(exec, str);
+          thisObj.put(exec, str2, obj);
+        } else {
+          // why delete something that's not there ? Strange.
+          thisObj.deleteProperty(exec, str);
+          thisObj.deleteProperty(exec, str2);
+        }
+      }
+    }
+    result = thisObj;
+    break;
+  }
+  case Shift: {
+    if (length == 0) {
+      thisObj.put(exec, "length", Number(length), DontEnum | DontDelete);
+      result = Undefined();
+    } else {
+      result = thisObj.get(exec, "0");
+      for(unsigned int k = 1; k < length; k++) {
+        UString str = UString::from(k);
+        UString str2 = UString::from(k-1);
+        if (thisObj.hasProperty(exec, str)) {
+          Value obj = thisObj.get(exec, str);
+          thisObj.put(exec, str2, obj);
+        } else
+          thisObj.deleteProperty(exec, str2);
+      }
+      thisObj.deleteProperty(exec, UString::from(length - 1));
+      thisObj.put(exec, "length", Number(length - 1), DontEnum | DontDelete);
+    }
+    break;
+  }
+  case Slice: {
+    // http://developer.netscape.com/docs/manuals/js/client/jsref/array.htm#1193713 or 15.4.4.10
+
+    // We return a new array
+    Object resObj = Object::dynamicCast(exec->interpreter()->builtinArray().construct(exec,List::empty()));
+    result = resObj;
+    int begin = args[0].toUInt32(exec);
+    if ( begin < 0 )
+      begin = maxInt( begin + length, 0 );
+    else
+      begin = minInt( begin, length );
+    int end = length;
+    if (args[1].type() != UndefinedType)
+    {
+      end = args[1].toUInt32(exec);
+      if ( end < 0 )
+        end = maxInt( end + length, 0 );
+      else
+        end = minInt( end, length );
+    }
+
+    //printf( "Slicing from %d to %d \n", begin, end );
+    for(unsigned int k = 0; k < (unsigned int) end-begin; k++) {
+      UString str = UString::from(k+begin);
+      if (thisObj.hasProperty(exec,str)) {
+        UString str2 = UString::from(k);
+        Value obj = thisObj.get(exec, str);
+        resObj.put(exec, str2, obj);
+      }
+    }
+    resObj.put(exec, "length", Number(end - begin), DontEnum | DontDelete);
+    break;
+  }
+  case Sort:{
+#if 0
+    printf("KJS Array::Sort length=%d\n", length);
+    for ( unsigned int i = 0 ; i<length ; ++i )
+      printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(UString::from(i)).toString().value().ascii() );
+#endif
+    Object sortFunction;
+    bool useSortFunction = (args[0].type() != UndefinedType);
+    if (useSortFunction)
+      {
+        sortFunction = args[0].toObject(exec);
+        if (!sortFunction.implementsCall())
+          useSortFunction = false;
+      }
+
+    if (length == 0) {
+      thisObj.put(exec, "length", Number(0), DontEnum | DontDelete);
+      result = Undefined();
+      break;
+    }
+
+    // "Min" sort. Not the fastest, but definitely less code than heapsort
+    // or quicksort, and much less swapping than bubblesort/insertionsort.
+    for ( unsigned int i = 0 ; i<length-1 ; ++i )
+      {
+        Value iObj = thisObj.get(exec,UString::from(i));
+        unsigned int themin = i;
+        Value minObj = iObj;
+        for ( unsigned int j = i+1 ; j<length ; ++j )
+          {
+            Value jObj = thisObj.get(exec,UString::from(j));
+            int cmp;
+            if ( useSortFunction )
+              {
+                List l;
+                l.append(jObj);
+                l.append(minObj);
+                Object thisObj = exec->interpreter()->globalObject();
+                cmp = sortFunction.call(exec,thisObj, l ).toInt32(exec);
+              }
+            else
+              cmp = (jObj.toString(exec) < minObj.toString(exec)) ? -1 : 1;
+            if ( cmp < 0 )
+              {
+                themin = j;
+                minObj = jObj;
+              }
+          }
+        // Swap themin and i
+        if ( themin > i )
+          {
+            //printf("KJS Array::Sort: swapping %d and %d\n", i, themin );
+            thisObj.put( exec, UString::from(i), minObj );
+            thisObj.put( exec, UString::from(themin), iObj );
+          }
+      }
+#if 0
+    printf("KJS Array::Sort -- Resulting array:\n");
+    for ( unsigned int i = 0 ; i<length ; ++i )
+      printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(UString::from(i)).toString().value().ascii() );
+#endif
+    result = thisObj;
+    break;
+  }
+  case Splice: {
+    // 15.4.4.12 - oh boy this is huge
+    Object resObj = Object::dynamicCast(exec->interpreter()->builtinArray().construct(exec,List::empty()));
+    result = resObj;
+    int begin = args[0].toUInt32(exec);
+    if ( begin < 0 )
+      begin = maxInt( begin + length, 0 );
+    else
+      begin = minInt( begin, length );
+    unsigned int deleteCount = minInt( maxInt( args[1].toUInt32(exec), 0 ), length - begin );
+
+    //printf( "Splicing from %d, deleteCount=%d \n", begin, deleteCount );
+    for(unsigned int k = 0; k < deleteCount; k++) {
+      UString str = UString::from(k+begin);
+      if (thisObj.hasProperty(exec,str)) {
+        UString str2 = UString::from(k);
+        Value obj = thisObj.get(exec, str);
+        resObj.put(exec, str2, obj);
+      }
+    }
+    resObj.put(exec, "length", Number(deleteCount), DontEnum | DontDelete);
+
+    unsigned int additionalArgs = maxInt( args.size() - 2, 0 );
+    if ( additionalArgs != deleteCount )
+    {
+      if ( additionalArgs < deleteCount )
+      {
+        for ( unsigned int k = begin; k < length - deleteCount; ++k )
+        {
+          UString str = UString::from(k+deleteCount);
+          UString str2 = UString::from(k+additionalArgs);
+          if (thisObj.hasProperty(exec,str)) {
+            Value obj = thisObj.get(exec, str);
+            thisObj.put(exec, str2, obj);
+          }
+          else
+            thisObj.deleteProperty(exec, str2);
+        }
+        for ( unsigned int k = length ; k > length - deleteCount + additionalArgs; --k )
+          thisObj.deleteProperty(exec, UString::from(k-1));
+      }
+      else
+      {
+        for ( unsigned int k = length - deleteCount; (int)k > begin; --k )
+        {
+          UString str = UString::from(k+deleteCount-1);
+          UString str2 = UString::from(k+additionalArgs-1);
+          if (thisObj.hasProperty(exec,str)) {
+            Value obj = thisObj.get(exec, str);
+            thisObj.put(exec, str2, obj);
+          }
+          else
+            thisObj.deleteProperty(exec, str2);
+        }
+      }
+    }
+    for ( unsigned int k = 0; k < additionalArgs; ++k )
+    {
+      thisObj.put(exec, UString::from(k+begin), args[k+2]);
+    }
+    thisObj.put(exec, "length", Number(length - deleteCount + additionalArgs), DontEnum | DontDelete);
+    break;
+  }
+  case UnShift: { // 15.4.4.13
+    unsigned int nrArgs = args.size();
+    for ( unsigned int k = length; k > 0; --k )
+    {
+      UString str = UString::from(k-1);
+      UString str2 = UString::from(k+nrArgs-1);
+      if (thisObj.hasProperty(exec,str)) {
+        Value obj = thisObj.get(exec, str);
+        thisObj.put(exec, str2, obj);
+      } else {
+        thisObj.deleteProperty(exec, str2);
+      }
+    }
+    for ( unsigned int k = 0; k < nrArgs; ++k )
+      thisObj.put(exec, UString::from(k), args[k]);
+    result = Number(length + nrArgs);
+    thisObj.put(exec, "length", result, DontEnum | DontDelete);
+    break;
+  }
+  default:
+    assert(0);
+    break;
+  }
+  return result;
+}
+
+// ------------------------------ ArrayObjectImp -------------------------------
+
+ArrayObjectImp::ArrayObjectImp(ExecState *exec,
+                               FunctionPrototypeImp *funcProto,
+                               ArrayPrototypeImp *arrayProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
   // ECMA 15.4.3.1 Array.prototype
-  setPrototypeProperty(arrayProto);
-}
-
-// ECMA 15.6.1
-Completion ArrayObject::execute(const List &args)
-{
-  // equivalent to 'new Array(....)'
-  KJSO result = construct(args);
-
-  return Completion(ReturnValue, result);
-}
-
-// ECMA 15.6.2
-Object ArrayObject::construct(const List &args)
-{
-  Object result = Object::create(ArrayClass);
+  put(exec,"prototype", Object(arrayProto), DontEnum|DontDelete|ReadOnly);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+}
+
+bool ArrayObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 15.4.2
+Object ArrayObjectImp::construct(ExecState *exec, const List &args)
+{
+  Object result(new ArrayInstanceImp(exec->interpreter()->builtinArrayPrototype()));
 
   unsigned int len;
   ListIterator it = args.begin();
   // a single argument might denote the array size
-  if (args.size() == 1 && it->isA(NumberType))
-    len = it->toUInt32();
+  if (args.size() == 1 && it->type() == NumberType)
+    len = it->toUInt32(exec);
   else {
     // initialize array
     len = args.size();
     for (unsigned int u = 0; it != args.end(); it++, u++)
-      result.put(UString::from(u), *it);
+      result.put(exec, UString::from(u), *it);
   }
 
   // array size
-  result.put("length", len, DontEnum | DontDelete);
+  result.put(exec, "length", Number(len), DontEnum | DontDelete);
+  static_cast<ArrayInstanceImp*>(result.imp())->putDirect(exec, "length", Number(len), DontEnum | DontDelete);
 
   return result;
 }
 
-// ECMA 15.6.4
-ArrayPrototype::ArrayPrototype(const Object& proto)
-  : ObjectImp(ArrayClass, Null(), proto)
-{
-  // The constructor will be added later in ArrayObject's constructor
-
-  put("length", 0u, DontEnum | DontDelete);
-}
-
-KJSO ArrayPrototype::get(const UString &p) const
-{
-  int id;
-  if(p == "toString")
-    id = ArrayProtoFunc::ToString;
-  else if(p == "toLocaleString")
-    id = ArrayProtoFunc::ToLocaleString;
-  else if(p == "concat")
-    id = ArrayProtoFunc::Concat;
-  else if (p == "join")
-    id = ArrayProtoFunc::Join;
-  else if(p == "pop")
-    id = ArrayProtoFunc::Pop;
-  else if(p == "push")
-    id = ArrayProtoFunc::Push;
-  else if(p == "reverse")
-    id = ArrayProtoFunc::Reverse;
-  else if(p == "shift")
-    id = ArrayProtoFunc::Shift;
-  else if(p == "slice")
-    id = ArrayProtoFunc::Slice;
-  else if(p == "sort")
-    id = ArrayProtoFunc::Sort;
-  else if(p == "splice")
-    id = ArrayProtoFunc::Splice;
-  else if(p == "unshift")
-    id = ArrayProtoFunc::UnShift;
-  else
-    return Imp::get(p);
-
-  return Function(new ArrayProtoFunc(id));
-}
-
-// ECMA 15.4.4
-Completion ArrayProtoFunc::execute(const List &args)
-{
-  KJSO result, obj, obj2;
-  Object thisObj = Object::dynamicCast(thisValue());
-  unsigned int length = thisObj.get("length").toUInt32();
-  unsigned int middle;
-  UString str = "", str2;
-  UString separator = ",";
-
-  switch (id) {
-  case ToLocaleString:
-    /* TODO */
-    // fall trough
-  case ToString:
-    if (!thisObj.getClass() == ArrayClass) {
-      result = Error::create(TypeError);
-      break;
-    }
-    // fall trough
-  case Join:
-    {
-      if (!args[0].isA(UndefinedType))
-        separator = args[0].toString().value();
-      for (unsigned int k = 0; k < length; k++) {
-        if (k >= 1)
-          str += separator;
-        obj = thisObj.get(UString::from(k));
-        if (!obj.isA(UndefinedType) && !obj.isA(NullType))
-          str += obj.toString().value();
-      }
-    }
-    result = String(str);
-    break;
-  case Concat: {
-    result = Object::create(ArrayClass);
-    int n = 0;
-    obj = thisObj;
-    ListIterator it = args.begin();
-    for (;;) {
-      if (obj.isA(ObjectType) &&
-          static_cast<Object&>(obj).getClass() == ArrayClass) {
-        unsigned int k = 0;
-        if (n > 0)
-          length = obj.get("length").toUInt32();
-        while (k < length) {
-          UString p = UString::from(k);
-          if (obj.hasProperty(p))
-            result.put(UString::from(n), obj.get(p));
-          n++;
-          k++;
-        }
-      } else {
-        result.put(UString::from(n), obj);
-        n++;      
-      }
-      if (it == args.end())
-        break;
-      obj = it++;
-    }
-    result.put("length", Number(n), DontEnum | DontDelete);
-  }
-    break;
-  case Pop:
-    if (length == 0) {
-      thisObj.put("length", Number(length), DontEnum | DontDelete);
-      result = Undefined();
-    } else {
-      str = UString::from(length - 1);
-      result = thisObj.get(str);
-      thisObj.deleteProperty(str);
-      thisObj.put("length", length - 1, DontEnum | DontDelete);
-    }
-    break;
-  case Push:
-    {
-      for (int n = 0; n < args.size(); n++)
-        thisObj.put(UString::from(length + n), args[n]);
-      length += args.size();
-      thisObj.put("length", length, DontEnum | DontDelete);
-      result = Number(length);
-    }
-    break;
-  case Reverse:
-    {
-      middle = length / 2;
-      for (unsigned int k = 0; k < middle; k++) {
-        str = UString::from(k);
-        str2 = UString::from(length - k - 1);
-        obj = thisObj.get(str);
-        obj2 = thisObj.get(str2);
-        if (thisObj.hasProperty(str2)) {
-          if (thisObj.hasProperty(str)) {
-            thisObj.put(str, obj2);
-            thisObj.put(str2, obj);
-          } else {
-            thisObj.put(str, obj2);
-            thisObj.deleteProperty(str2);
-          }
-        } else {
-          if (thisObj.hasProperty(str)) {
-            thisObj.deleteProperty(str);
-            thisObj.put(str2, obj);
-          } else {
-            // why delete something that's not there ? Strange.
-            thisObj.deleteProperty(str);
-            thisObj.deleteProperty(str2);
-          }
-        }
-      }
-    }
-    result = thisObj;
-    break;
-  case Shift:
-    if (length == 0) {
-      thisObj.put("length", Number(length), DontEnum | DontDelete);
-      result = Undefined();
-    } else {
-      result = thisObj.get("0");
-      for(unsigned int k = 1; k < length; k++) {
-        str = UString::from(k);
-        str2 = UString::from(k-1);
-        if (thisObj.hasProperty(str)) {
-          obj = thisObj.get(str);
-          thisObj.put(str2, obj);
-        } else
-          thisObj.deleteProperty(str2);
-      }
-      thisObj.deleteProperty(UString::from(length - 1));
-      thisObj.put("length", length - 1, DontEnum | DontDelete);
-    }
-    break;
-  case Slice: // http://developer.netscape.com/docs/manuals/js/client/jsref/array.htm#1193713
-    {
-        result = Object::create(ArrayClass); // We return a new array
-        int begin = args[0].toUInt32();
-        int end = length;
-        if (!args[1].isA(UndefinedType))
-        {
-          end = args[1].toUInt32();
-          if ( end < 0 )
-            end += length;
-        }
-        // safety tests
-        if ( begin < 0 || end < 0 || begin >= end ) {
-            result.put("length", Number(0), DontEnum | DontDelete);
-            break;
-        }
-        //printf( "Slicing from %d to %d \n", begin, end );
-        for(unsigned int k = 0; k < (unsigned int) end-begin; k++) {
-            str = UString::from(k+begin);
-            str2 = UString::from(k);
-            if (thisObj.hasProperty(str)) {
-                obj = thisObj.get(str);
-                result.put(str2, obj);
-            }
-        }
-        result.put("length", end - begin, DontEnum | DontDelete);
-        break;
-    }
-  case Sort:
-    {
-#if 0
-        printf("KJS Array::Sort length=%d\n", length);
-        for ( unsigned int i = 0 ; i<length ; ++i )
-            printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(UString::from(i)).toString().value().ascii() );
-#endif
-        Object sortFunction;
-        bool useSortFunction = !args[0].isA(UndefinedType);
-        if (useSortFunction)
-        {
-            sortFunction = args[0].toObject();
-            if (!sortFunction.implementsCall())
-                useSortFunction = false;
-        }
-
-        if (length == 0) {
-            thisObj.put("length", Number(0), DontEnum | DontDelete);
-            result = Undefined();
-            break;
-        }
-
-        // "Min" sort. Not the fastest, but definitely less code than heapsort
-        // or quicksort, and much less swapping than bubblesort/insertionsort.
-        for ( unsigned int i = 0 ; i<length-1 ; ++i )
-        {
-            KJSO iObj = thisObj.get(UString::from(i));
-            unsigned int themin = i;
-            KJSO minObj = iObj;
-            for ( unsigned int j = i+1 ; j<length ; ++j )
-            {
-                KJSO jObj = thisObj.get(UString::from(j));
-                int cmp;
-                if ( useSortFunction )
-                {
-                    List l;
-                    l.append(jObj);
-                    l.append(minObj);
-                    cmp = sortFunction.executeCall( Global::current(), &l ).toInt32();
-                }
-                else
-                    cmp = ( jObj.toString().value() < minObj.toString().value() ) ? -1 : 1;
-                if ( cmp < 0 )
-                {
-                    themin = j;
-                    minObj = jObj;
-                }
-            }
-            // Swap themin and i
-            if ( themin > i )
-            {
-                //printf("KJS Array::Sort: swapping %d and %d\n", i, themin );
-                thisObj.put( UString::from(i), minObj );
-                thisObj.put( UString::from(themin), iObj );
-            }
-        }
-#if 0
-        printf("KJS Array::Sort -- Resulting array:\n");
-        for ( unsigned int i = 0 ; i<length ; ++i )
-            printf("KJS Array::Sort: %d: %s\n", i, thisObj.get(UString::from(i)).toString().value().ascii() );
-#endif
-        result = thisObj;
-        break;
-    }
-  // TODO Splice
-  // TODO Unshift
-  default:
-    result = Undefined();
-  }
-
-  return Completion(ReturnValue, result);
-}
+bool ArrayObjectImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.6.1
+Value ArrayObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  // equivalent to 'new Array(....)'
+  return construct(exec,args);
+}
+

trunk/JavaScriptCore/kjs/array_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _ARRAY_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class ArrayObject : public ConstructorImp {
+  class ArrayInstanceImp : public ObjectImp {
   public:
-    ArrayObject(const Object &funcProto, const Object &arrayProto);
-    Completion execute(const List &);
-    Object construct(const List &);
+    ArrayInstanceImp(const Object &proto);
+
+    virtual void put(ExecState *exec, const UString &propertyName, const Value &value, int attr = None);
+    virtual void putDirect(ExecState *exec, const UString &propertyName, const Value &value, int attr = None);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   };
 
-  class ArrayPrototype : public ObjectImp {
+ class ArrayPrototypeImp : public ArrayInstanceImp {
   public:
-    ArrayPrototype(const Object& proto);
-    virtual KJSO get(const UString &p) const;
+    ArrayPrototypeImp(ExecState *exec,
+                      ObjectPrototypeImp *objProto);
+    Value get(ExecState *exec, const UString &p) const;
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   };
 
-  class ArrayProtoFunc : public InternalFunctionImp {
+  class ArrayProtoFuncImp : public InternalFunctionImp {
   public:
-    ArrayProtoFunc(int i) : id(i) { }
-    Completion execute(const List &);
+    ArrayProtoFuncImp(ExecState *exec, int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
     enum { ToString, ToLocaleString, Concat, Join, Pop, Push,
            Reverse, Shift, Slice, Sort, Splice, UnShift };
@@ -49 +62 @@
   };
 
+  class ArrayObjectImp : public InternalFunctionImp {
+  public:
+    ArrayObjectImp(ExecState *exec,
+                   FunctionPrototypeImp *funcProto,
+                   ArrayPrototypeImp *arrayProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+  };
+
 }; // namespace
 

trunk/JavaScriptCore/kjs/bool_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
+ *
  */
 
-#include "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "operations.h"
-#include "types.h"
 #include "bool_object.h"
 #include "error_object.h"
 
+#include <assert.h>
+
 using namespace KJS;
 
-BooleanObject::BooleanObject(const KJSO& funcProto, const KJSO &booleanProto)
-  : ConstructorImp(funcProto, 1)
+// ------------------------------ BooleanInstanceImp ---------------------------
+
+const ClassInfo BooleanInstanceImp::info = {"Boolean", 0, 0, 0};
+
+BooleanInstanceImp::BooleanInstanceImp(const Object &proto)
+  : ObjectImp(proto)
 {
-  // Boolean.prototype
-  setPrototypeProperty(booleanProto);
+}
+
+// ------------------------------ BooleanPrototypeImp --------------------------
+
+// ECMA 15.6.4
+
+BooleanPrototypeImp::BooleanPrototypeImp(ExecState *exec,
+                                         ObjectPrototypeImp *objectProto,
+                                         FunctionPrototypeImp *funcProto)
+  : BooleanInstanceImp(Object(objectProto))
+{
+  Value protect(this);
+  // The constructor will be added later by InterpreterImp::InterpreterImp()
+
+  put(exec,"toString", Object(new BooleanProtoFuncImp(exec,funcProto,BooleanProtoFuncImp::ToString,0)), DontEnum);
+  put(exec,"valueOf",  Object(new BooleanProtoFuncImp(exec,funcProto,BooleanProtoFuncImp::ValueOf,0)),  DontEnum);
+  setInternalValue(Boolean(false));
+}
+
+
+// ------------------------------ BooleanProtoFuncImp --------------------------
+
+BooleanProtoFuncImp::BooleanProtoFuncImp(ExecState *exec,
+                                         FunctionPrototypeImp *funcProto, int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+
+bool BooleanProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+
+// ECMA 15.6.4.2 + 15.6.4.3
+Value BooleanProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &/*args*/)
+{
+  // no generic function. "this" has to be a Boolean object
+  if (!thisObj.inherits(&BooleanInstanceImp::info)) {
+    Object err = Error::create(exec,TypeError);
+    exec->setException(err);
+    return err;
+  }
+
+  // execute "toString()" or "valueOf()", respectively
+
+  Value v = thisObj.internalValue();
+  assert(!v.isNull());
+
+  if (id == ToString)
+    return String(v.toString(exec));
+  else
+    return Boolean(v.toBoolean(exec)); /* TODO: optimize for bool case */
+}
+
+// ------------------------------ BooleanObjectImp -----------------------------
+
+
+BooleanObjectImp::BooleanObjectImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                                   BooleanPrototypeImp *booleanProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
+  put(exec,"prototype", Object(booleanProto),DontEnum|DontDelete|ReadOnly);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+}
+
+
+bool BooleanObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 15.6.2
+Object BooleanObjectImp::construct(ExecState *exec, const List &args)
+{
+  Object proto = exec->interpreter()->builtinBooleanPrototype();
+  Object obj(new BooleanInstanceImp(proto));
+
+  Boolean b;
+  if (args.size() > 0)
+    b = args.begin()->toBoolean(exec);
+  else
+    b = Boolean(false);
+
+  obj.setInternalValue(b);
+
+  return obj;
+}
+
+bool BooleanObjectImp::implementsCall() const
+{
+  return true;
 }
 
 // ECMA 15.6.1
-Completion BooleanObject::execute(const List &args)
+Value BooleanObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
 {
-  Boolean b;
-
   if (args.isEmpty())
-    b = Boolean(false);
+    return Boolean(false);
   else
-    b = args[0].toBoolean();
-
-  return Completion(ReturnValue, b);
+    return Boolean(args[0].toBoolean(exec)); /* TODO: optimize for bool case */
 }
 
-// ECMA 15.6.2
-Object BooleanObject::construct(const List &args)
-{
-  Boolean b;
-  if (args.size() > 0)
-    b = args.begin()->toBoolean();
-  else
-    b = Boolean(false);
-
-  return Object::create(BooleanClass, b);
-}
-
-// ECMA 15.6.4
-BooleanPrototype::BooleanPrototype(const Object& proto)
-  : ObjectImp(BooleanClass, Boolean(false), proto)
-{
-  // The constructor will be added later in BooleanObject's constructor
-}
-
-KJSO BooleanPrototype::get(const UString &p) const
-{
-  if (p == "toString")
-    return Function(new BooleanProtoFunc(ToString));
-  else if (p == "valueOf")
-    return Function(new BooleanProtoFunc(ValueOf));
-  else
-    return Imp::get(p);
-}
-
-BooleanProtoFunc::BooleanProtoFunc(int i)
-  : id(i)
-{
-}
-
-// ECMA 15.6.4.2 + 15.6.4.3
-Completion BooleanProtoFunc::execute(const List &)
-{
-  KJSO result;
-
-  Object thisObj = Object::dynamicCast(thisValue());
-
-  // no generic function. "this" has to be a Boolean object
-  if (thisObj.isNull() || thisObj.getClass() != BooleanClass) {
-    result = Error::create(TypeError);
-    return Completion(ReturnValue, result);
-  }
-
-  // execute "toString()" or "valueOf()", respectively
-  KJSO v = thisObj.internalValue();
-  if (id == BooleanPrototype::ToString)
-    result = v.toString();
-  else
-    result = v.toBoolean();
-
-  return Completion(ReturnValue, result);
-}

trunk/JavaScriptCore/kjs/bool_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _BOOL_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class BooleanObject : public ConstructorImp {
+  class BooleanInstanceImp : public ObjectImp {
   public:
-    BooleanObject(const KJSO& funcProto, const KJSO &booleanProto);
-    Completion execute(const List &);
-    Object construct(const List &);
+    BooleanInstanceImp(const Object &proto);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   };
 
-  class BooleanPrototype : public ObjectImp {
+  /**
+   * @internal
+   *
+   * The initial value of Boolean.prototype (and thus all objects created
+   * with the Boolean constructor
+   */
+  class BooleanPrototypeImp : public BooleanInstanceImp {
   public:
-    BooleanPrototype(const Object& proto);
-    virtual KJSO get(const UString &p) const;
-    enum { ToString, ValueOf };
+    BooleanPrototypeImp(ExecState *exec,
+                        ObjectPrototypeImp *objectProto,
+                        FunctionPrototypeImp *funcProto);
   };
 
-  class BooleanProtoFunc : public InternalFunctionImp {
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * Boolean.prototype object
+   */
+  class BooleanProtoFuncImp : public InternalFunctionImp {
   public:
-    BooleanProtoFunc(int i);
-    Completion execute(const List &);
+    BooleanProtoFuncImp(ExecState *exec,
+                        FunctionPrototypeImp *funcProto, int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    enum { ToString, ValueOf };
   private:
     int id;
+  };
+
+  /**
+   * @internal
+   *
+   * The initial value of the the global variable's "Boolean" property
+   */
+  class BooleanObjectImp : public InternalFunctionImp {
+    friend class BooleanProtoFuncImp;
+  public:
+    BooleanObjectImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                     BooleanPrototypeImp *booleanProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
   };
 

trunk/JavaScriptCore/kjs/collector.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -16 +18 @@
  *  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 "collector.h"
-#include "object.h"
 #include "internal.h"
 
@@ -25 +28 @@
 #include <string.h>
 #include <assert.h>
+#ifdef KJS_DEBUG_MEM
+#include <typeinfo>
+#endif
 
 namespace KJS {
@@ -62 +68 @@
 unsigned long Collector::filled = 0;
 unsigned long Collector::softLimit = KJS_MEM_INCREMENT;
+
+unsigned long Collector::timesFilled = 0;
+unsigned long Collector::increaseLimitAt = 1;
+
+bool Collector::memLimitReached = false;
+
 #ifdef KJS_DEBUG_MEM
 bool Collector::collecting = false;
@@ -71 +83 @@
     return 0L;
 
+  // Try and deal with memory requirements in a scalable way. Simple scripts
+  // should only require small amounts of memory, but for complex scripts we don't
+  // want to end up running the garbage collector hundreds of times a second.
   if (filled >= softLimit) {
+    timesFilled++;
     collect();
-    if (filled >= softLimit && softLimit < KJS_MEM_LIMIT) // we are actually using all this memory
+
+    if (filled >= softLimit && softLimit < KJS_MEM_LIMIT) {
+      // Even after collection we are still using more than the limit, so increase
+      // the limit
       softLimit *= 2;
+    }
+    else if (timesFilled == increaseLimitAt && increaseLimitAt < 128) {
+      // The allowed memory limit keeps getting reached (lots of objects created
+      // and deleted). Increase it a bit so GC gets run less often.
+      timesFilled = 0;
+      softLimit *= 2;
+      increaseLimitAt *= 2;
+    }
   }
 
   void *m = malloc(s);
-
-  // hack to ensure obj is protected from GC before any constructors are run
-  // (prev = marked, next = gcallowed)
-  static_cast<Imp*>(m)->prev = 0;
-  static_cast<Imp*>(m)->next = 0;
+#ifdef KJS_DEBUG_MEM
+  //fprintf( stderr, "allocate: size=%d valueimp=%p\n",s,m);
+#endif
+
+  // VI_CREATED and VI_GCALLOWED being unset ensure that value
+  // is protected from GC before any constructors are run
+  static_cast<ValueImp*>(m)->_flags = 0;
 
   if (!root) {
@@ -99 +128 @@
   if (block->filled >= block->size) {
 #ifdef KJS_DEBUG_MEM
-    printf("allocating new block of size %d\n", block->size);
+    //fprintf( stderr, "allocating new block of size %d\n", block->size);
 #endif
     CollectorBlock *tmp = new CollectorBlock(BlockSize);
@@ -116 +145 @@
 
   if (softLimit >= KJS_MEM_LIMIT) {
-      KJScriptImp::setException("Out of memory");
+    memLimitReached = true;
+    fprintf(stderr,"Out of memory");
   }
 
@@ -125 +155 @@
  * Mark-sweep garbage collection.
  */
-void Collector::collect()
-{
-#ifdef KJS_DEBUG_MEM
-  printf("collecting %d objects total\n", Imp::count);
-  collecting = true;
-#endif
-
-  // MARK: first set all ref counts to 0 ....
+bool Collector::collect()
+{
+#ifdef KJS_DEBUG_MEM
+  fprintf(stderr,"Collector::collect()\n");
+#endif
+  bool deleted = false;
+  // MARK: first unmark everything
   CollectorBlock *block = root;
   while (block) {
-#ifdef KJS_DEBUG_MEM
-    printf("cleaning block filled %d out of %d\n", block->filled, block->size);
-#endif
-    Imp **r = (Imp**)block->mem;
+    ValueImp **r = (ValueImp**)block->mem;
     assert(r);
     for (int i = 0; i < block->size; i++, r++)
       if (*r) {
-        (*r)->setMarked(false);
-      }
-    block = block->next;
-  }
-
-  // ... increase counter for all referenced objects recursively
+        (*r)->_flags &= ~ValueImp::VI_MARKED;
+      }
+    block = block->next;
+  }
+
+  // mark all referenced objects recursively
   // starting out from the set of root objects
-  if (KJScriptImp::hook) {
-    KJScriptImp *scr = KJScriptImp::hook;
+  if (InterpreterImp::s_hook) {
+    InterpreterImp *scr = InterpreterImp::s_hook;
     do {
+      //fprintf( stderr, "Collector marking interpreter %p\n",(void*)scr);
       scr->mark();
       scr = scr->next;
-    } while (scr != KJScriptImp::hook);
+    } while (scr != InterpreterImp::s_hook);
   }
 
@@ -160 +187 @@
   block = root;
   while (block) {
-    Imp **r = (Imp**)block->mem;
+    ValueImp **r = (ValueImp**)block->mem;
     assert(r);
     for (int i = 0; i < block->size; i++, r++)
-      if (*r && (*r)->created() && ((*r)->refcount || !(*r)->gcAllowed()) && !(*r)->marked())
-        (*r)->mark();
+    {
+      ValueImp *imp = (*r);
+      // Check for created=true, marked=false and (gcallowed=false or refcount>0)
+      if (imp &&
+          (imp->_flags & (ValueImp::VI_CREATED|ValueImp::VI_MARKED)) == ValueImp::VI_CREATED &&
+          ( (imp->_flags & ValueImp::VI_GCALLOWED) == 0 || imp->refcount ) ) {
+        //fprintf( stderr, "Collector marking imp=%p\n",(void*)imp);
+        imp->mark();
+      }
+    }
     block = block->next;
   }
@@ -171 +206 @@
   block = root;
   while (block) {
-    Imp **r = (Imp**)block->mem;
+    ValueImp **r = (ValueImp**)block->mem;
     int del = 0;
     for (int i = 0; i < block->size; i++, r++) {
-      if (*r && ((*r)->refcount == 0) && !(*r)->marked() && (*r)->gcAllowed()) {
-        // emulate destructing part of 'operator delete()'
-        (*r)->~Imp();
-        free(*r);
-        *r = 0L;
-        del++;
+      ValueImp *imp = (*r);
+      // Can delete if refcount==0, created==true, gcAllowed==true, and marked==false
+      // Make sure to update the test if you add more bits to _flags.
+      if (imp &&
+          !imp->refcount && imp->_flags == (ValueImp::VI_GCALLOWED | ValueImp::VI_CREATED)) {
+        // emulate destructing part of 'operator delete()'
+        //fprintf( stderr, "Collector::deleting ValueImp %p (%s)\n", (void*)imp, typeid(*imp).name());
+        imp->~ValueImp();
+        free(imp);
+        *r = 0L;
+        del++;
       }
     }
@@ -185 +225 @@
     block->filled -= del;
     block = block->next;
-  }
-
-  // delete the emtpy containers
+    if (del)
+      deleted = true;
+  }
+
+  // delete the empty containers
   block = root;
   while (block) {
@@ -193 +235 @@
     if (block->filled == 0) {
       if (block->prev)
-        block->prev->next = next;
+        block->prev->next = next;
       if (block == root)
-        root = next;
+        root = next;
       if (next)
-        next->prev = block->prev;
+        next->prev = block->prev;
       if (block == currentBlock) // we don't want a dangling pointer
-        currentBlock = 0L;
+        currentBlock = 0L;
       assert(block != root);
       delete block;
@@ -205 +247 @@
     block = next;
   }
-
-#ifdef KJS_DEBUG_MEM
-  collecting = false;
-#endif
-}
+#if 0
+  // This is useful to track down memory leaks
+  static int s_count = 0;
+  fprintf(stderr, "Collector done (was run %d)\n",s_count);
+  if (s_count++ % 50 == 2)
+    finalCheck();
+#endif
+  return deleted;
+}
+
+#ifdef KJS_DEBUG_MEM
+void Collector::finalCheck()
+{
+  CollectorBlock *block = root;
+  while (block) {
+    ValueImp **r = (ValueImp**)block->mem;
+    for (int i = 0; i < block->size; i++, r++) {
+      if (*r ) {
+        fprintf( stderr, "Collector::finalCheck() still having ValueImp %p (%s)  [marked:%d gcAllowed:%d created:%d refcount:%d]\n",
+                 (void*)(*r), typeid( **r ).name(),
+                 (bool)((*r)->_flags & ValueImp::VI_MARKED),
+                 (bool)((*r)->_flags & ValueImp::VI_GCALLOWED),
+                 (bool)((*r)->_flags & ValueImp::VI_CREATED),
+                 (*r)->refcount);
+      }
+    }
+    block = block->next;
+  }
+}
+#endif

trunk/JavaScriptCore/kjs/collector.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -16 +18 @@
  *  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$
  */
 
@@ -40 +44 @@
 #include <stdlib.h>
 
+// for DEBUG_*
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
+
 namespace KJS {
 
-  class Imp;
   class CollectorBlock;
 
@@ -66 +75 @@
      * Run the garbage collection. This involves calling the delete operator
      * on each object and freeing the used memory.
-     * In the current implemenation this will basically free all registered
-     * object regardless whether they are still references by others or not.
-     * 
      */
-    static void collect();
+    static bool collect();
     static int size() { return filled; }
+    static bool outOfMemory() { return memLimitReached; }
 
 #ifdef KJS_DEBUG_MEM
+    /** Check that nothing is left when the last interpreter gets deleted */
+    static void finalCheck();
     /**
      * @internal
@@ -84 +93 @@
     static unsigned long filled;
     static unsigned long softLimit;
+    static unsigned long timesFilled;
+    static unsigned long increaseLimitAt;
+    static bool memLimitReached;
     enum { BlockSize = 100 };
   };

trunk/JavaScriptCore/kjs/date_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$
  */
 
@@ -46 +49 @@
 #include <string.h>
 #include <stdio.h>
+#include <stdlib.h>
 #include <locale.h>
-
-#include "kjs.h"
+#include <ctype.h>
+
 #include "date_object.h"
-
-namespace KJS {
-
-  class DateObjectFunc : public InternalFunctionImp {
-  public:
-    DateObjectFunc(int i) : id(i) { };
-    Completion execute(const List &);
-    enum { Parse, UTC };
-  private:
-    int id;
-  };
-
-  class DateProtoFunc : public InternalFunctionImp {
-  public:
-    DateProtoFunc(int i, bool u);
-    Completion execute(const List &);
-    enum { ToString, ToDateString, ToTimeString, ToLocaleString,
-           ToLocaleDateString, ToLocaleTimeString, ValueOf, GetTime,
-           GetFullYear, GetMonth, GetDate, GetDay, GetHours, GetMinutes,
-           GetSeconds, GetMilliSeconds, GetTimezoneOffset, SetTime,
-           SetMilliSeconds, SetSeconds, SetMinutes, SetHours, SetDate,
-           SetMonth, SetFullYear, ToUTCString,
-           // non-normative properties (Appendix B)
-           GetYear, SetYear, ToGMTString };
-  private:
-    int id;
-    bool utc;
-  };
-
-  // helper functions
-  KJSO parseDate(const String &s);
-  KJSO timeClip(const KJSO &t);
-};
+#include "error_object.h"
+#include "operations.h"
+
+#include "date_object.lut.h"
 
 using namespace KJS;
 
-KJSO KJS::parseDate(const String &s)
+// ------------------------------ DateInstanceImp ------------------------------
+
+const ClassInfo DateInstanceImp::info = {"Date", 0, 0, 0};
+
+DateInstanceImp::DateInstanceImp(const Object &proto)
+  : ObjectImp(proto)
+{
+}
+
+// ------------------------------ DatePrototypeImp -----------------------------
+
+const ClassInfo DatePrototypeImp::info = {"Date", 0, &dateTable, 0};
+
+/* Source for date_object.lut.h
+   We use a negative ID to denote the "UTC" variant.
+@begin dateTable 61
+  toString              DateProtoFuncImp::ToString              DontEnum|Function       0
+  toUTCString           -DateProtoFuncImp::ToString             DontEnum|Function       0
+  toDateString          DateProtoFuncImp::ToDateString          DontEnum|Function       0
+  toTimeString          DateProtoFuncImp::ToTimeString          DontEnum|Function       0
+  toLocaleString        DateProtoFuncImp::ToLocaleString        DontEnum|Function       0
+  toLocaleDateString    DateProtoFuncImp::ToLocaleDateString    DontEnum|Function       0
+  toLocaleTimeString    DateProtoFuncImp::ToLocaleTimeString    DontEnum|Function       0
+  valueOf               DateProtoFuncImp::ValueOf               DontEnum|Function       0
+  getTime               DateProtoFuncImp::GetTime               DontEnum|Function       0
+  getFullYear           DateProtoFuncImp::GetFullYear           DontEnum|Function       0
+  getUTCFullYear        -DateProtoFuncImp::GetFullYear          DontEnum|Function       0
+  toGMTString           DateProtoFuncImp::ToGMTString           DontEnum|Function       0
+  getMonth              DateProtoFuncImp::GetMonth              DontEnum|Function       0
+  getUTCMonth           -DateProtoFuncImp::GetMonth             DontEnum|Function       0
+  getDate               DateProtoFuncImp::GetDate               DontEnum|Function       0
+  getUTCDate            -DateProtoFuncImp::GetDate              DontEnum|Function       0
+  getDay                DateProtoFuncImp::GetDay                DontEnum|Function       0
+  getUTCDay             -DateProtoFuncImp::GetDay               DontEnum|Function       0
+  getHours              DateProtoFuncImp::GetHours              DontEnum|Function       0
+  getUTCHours           -DateProtoFuncImp::GetHours             DontEnum|Function       0
+  getMinutes            DateProtoFuncImp::GetMinutes            DontEnum|Function       0
+  getUTCMinutes         -DateProtoFuncImp::GetMinutes           DontEnum|Function       0
+  getSeconds            DateProtoFuncImp::GetSeconds            DontEnum|Function       0
+  getUTCSeconds         -DateProtoFuncImp::GetSeconds           DontEnum|Function       0
+  getMilliseconds       DateProtoFuncImp::GetMilliSeconds       DontEnum|Function       0
+  getUTCMilliseconds    -DateProtoFuncImp::GetMilliSeconds      DontEnum|Function       0
+  getTimezoneOffset     DateProtoFuncImp::GetTimezoneOffset     DontEnum|Function       0
+  setTime               DateProtoFuncImp::SetTime               DontEnum|Function       1
+  setMilliseconds       DateProtoFuncImp::SetMilliSeconds       DontEnum|Function       1
+  setUTCMilliseconds    -DateProtoFuncImp::SetMilliSeconds      DontEnum|Function       1
+  setSeconds            DateProtoFuncImp::SetSeconds            DontEnum|Function       2
+  setUTCSeconds         -DateProtoFuncImp::SetSeconds           DontEnum|Function       2
+  setMinutes            DateProtoFuncImp::SetMinutes            DontEnum|Function       3
+  setUTCMinutes         -DateProtoFuncImp::SetMinutes           DontEnum|Function       3
+  setHours              DateProtoFuncImp::SetHours              DontEnum|Function       4
+  setUTCHours           -DateProtoFuncImp::SetHours             DontEnum|Function       4
+  setDate               DateProtoFuncImp::SetDate               DontEnum|Function       1
+  setUTCDate            -DateProtoFuncImp::SetDate              DontEnum|Function       1
+  setMonth              DateProtoFuncImp::SetMonth              DontEnum|Function       2
+  setUTCMonth           -DateProtoFuncImp::SetMonth             DontEnum|Function       2
+  setFullYear           DateProtoFuncImp::SetFullYear           DontEnum|Function       3
+  setUTCFullYear        -DateProtoFuncImp::SetFullYear          DontEnum|Function       3
+  setYear               DateProtoFuncImp::SetYear               DontEnum|Function       1
+  getYear               DateProtoFuncImp::GetYear               DontEnum|Function       0
+  toGMTString           DateProtoFuncImp::ToGMTString           DontEnum|Function       0
+@end
+*/
+// ECMA 15.9.4
+
+DatePrototypeImp::DatePrototypeImp(ExecState *,
+                                   ObjectPrototypeImp *objectProto)
+  : DateInstanceImp(Object(objectProto))
+{
+  Value protect(this);
+  setInternalValue(Number(NaN));
+  // The constructor will be added later, after DateObjectImp has been built
+}
+
+Value DatePrototypeImp::get(ExecState *exec, const UString &propertyName) const
+{
+  return lookupGetFunction<DateProtoFuncImp, ObjectImp>( exec, propertyName, &dateTable, this );
+}
+
+// ------------------------------ DateProtoFuncImp -----------------------------
+
+DateProtoFuncImp::DateProtoFuncImp(ExecState *exec, int i, int len)
+  : InternalFunctionImp(
+    static_cast<FunctionPrototypeImp*>(exec->interpreter()->builtinFunctionPrototype().imp())
+    ), id(abs(i)), utc(i<0)
+  // We use a negative ID to denote the "UTC" variant.
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+bool DateProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+Value DateProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  if ((id == ToString || id == ValueOf || id == GetTime || id == SetTime) &&
+      !thisObj.inherits(&DateInstanceImp::info)) {
+    // non-generic function called on non-date object
+
+    // ToString and ValueOf are generic according to the spec, but the mozilla
+    // tests suggest otherwise...
+    Object err = Error::create(exec,TypeError);
+    exec->setException(err);
+    return err;
+  }
+
+
+  Value result;
+  UString s;
+  const int bufsize=100;
+  char timebuffer[bufsize];
+  char *oldlocale = setlocale(LC_TIME,NULL);
+  if (!oldlocale)
+    oldlocale = setlocale(LC_ALL, NULL);
+  Value v = thisObj.internalValue();
+  double milli = v.toNumber(exec);
+  time_t tv = (time_t) floor(milli / 1000.0);
+  int ms = int(milli - tv * 1000.0);
+
+  struct tm *t;
+  if (utc)
+    t = gmtime(&tv);
+  else
+    t = localtime(&tv);
+
+  switch (id) {
+  case ToString:
+    s = ctime(&tv);
+    result = String(s.substr(0, s.size() - 1));
+    break;
+  case ToDateString:
+  case ToTimeString:
+  case ToGMTString:
+    setlocale(LC_TIME,"C");
+    if (id == DateProtoFuncImp::ToDateString) {
+      strftime(timebuffer, bufsize, "%x",t);
+    } else if (id == DateProtoFuncImp::ToTimeString) {
+      strftime(timebuffer, bufsize, "%X",t);
+    } else {
+      t = gmtime(&tv);
+      strftime(timebuffer, bufsize, "%a, %d-%b-%y %H:%M:%S %Z", t);
+    }
+    setlocale(LC_TIME,oldlocale);
+    result = String(timebuffer);
+    break;
+  case ToLocaleString:
+    strftime(timebuffer, bufsize, "%c", t);
+    result = String(timebuffer);
+    break;
+  case ToLocaleDateString:
+    strftime(timebuffer, bufsize, "%x", t);
+    result = String(timebuffer);
+    break;
+  case ToLocaleTimeString:
+    strftime(timebuffer, bufsize, "%X", t);
+    result = String(timebuffer);
+    break;
+  case ValueOf:
+    result = Number(milli);
+    break;
+  case GetTime:
+    result = Number(milli);
+    break;
+  case GetYear:
+    // IE returns the full year even in getYear.
+    if ( exec->interpreter()->compatMode() == Interpreter::IECompat )
+      result = Number(1900 + t->tm_year);
+    else
+      result = Number(t->tm_year);
+    break;
+  case GetFullYear:
+    result = Number(1900 + t->tm_year);
+    break;
+  case GetMonth:
+    result = Number(t->tm_mon);
+    break;
+  case GetDate:
+    result = Number(t->tm_mday);
+    break;
+  case GetDay:
+    result = Number(t->tm_wday);
+    break;
+  case GetHours:
+    result = Number(t->tm_hour);
+    break;
+  case GetMinutes:
+    result = Number(t->tm_min);
+    break;
+  case GetSeconds:
+    result = Number(t->tm_sec);
+    break;
+  case GetMilliSeconds:
+    result = Number(ms);
+    break;
+  case GetTimezoneOffset:
+#if defined BSD || defined(__APPLE__)
+    result = Number(-( t->tm_gmtoff / 60 ) + ( t->tm_isdst ? 60 : 0 ));
+#else
+#  if defined(__BORLANDC__)
+#error please add daylight savings offset here!
+    result = Number(_timezone / 60 - (_daylight ? 60 : 0));
+#  else
+    result = Number(( timezone / 60 - ( daylight ? 60 : 0 )));
+#  endif
+#endif
+    break;
+  case SetTime:
+    milli = roundValue(exec,args[0]);
+    result = Number(milli);
+    thisObj.setInternalValue(result);
+    break;
+  case SetMilliSeconds:
+    ms = args[0].toInt32(exec);
+    break;
+  case SetSeconds:
+    t->tm_sec = args[0].toInt32(exec);
+    break;
+  case SetMinutes:
+    t->tm_min = args[0].toInt32(exec);
+    break;
+  case SetHours:
+    t->tm_hour = args[0].toInt32(exec);
+    break;
+  case SetDate:
+    t->tm_mday = args[0].toInt32(exec);
+    break;
+  case SetMonth:
+    t->tm_mon = args[0].toInt32(exec);
+    break;
+  case SetFullYear:
+    t->tm_year = args[0].toInt32(exec) - 1900;
+    break;
+  case SetYear:
+    t->tm_year = args[0].toInt32(exec) >= 1900 ? args[0].toInt32(exec) - 1900 : args[0].toInt32(exec);
+    break;
+  }
+
+  if (id == SetYear || id == SetMilliSeconds || id == SetSeconds ||
+      id == SetMinutes || id == SetHours || id == SetDate ||
+      id == SetMonth || id == SetFullYear ) {
+    result = Number(mktime(t) * 1000.0 + ms);
+    thisObj.setInternalValue(result);
+  }
+
+  return result;
+}
+
+// ------------------------------ DateObjectImp --------------------------------
+
+// TODO: MakeTime (15.9.11.1) etc. ?
+
+DateObjectImp::DateObjectImp(ExecState *exec,
+                             FunctionPrototypeImp *funcProto,
+                             DatePrototypeImp *dateProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
+  // ECMA 15.9.4.1 Date.prototype
+  put(exec,"prototype", Object(dateProto), DontEnum|DontDelete|ReadOnly);
+
+  put(exec,"parse", Object(new DateObjectFuncImp(exec,funcProto,DateObjectFuncImp::Parse, 1)), DontEnum);
+  put(exec,"UTC",   Object(new DateObjectFuncImp(exec,funcProto,DateObjectFuncImp::UTC,   7)),   DontEnum);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(7), ReadOnly|DontDelete|DontEnum);
+}
+
+bool DateObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 15.9.3
+Object DateObjectImp::construct(ExecState *exec, const List &args)
+{
+  int numArgs = args.size();
+
+#ifdef KJS_VERBOSE
+  fprintf(stderr,"DateObjectImp::construct - %d args\n", numArgs);
+#endif
+  Value value;
+
+  if (numArgs == 0) { // new Date() ECMA 15.9.3.3
+#if HAVE_SYS_TIMEB_H
+#  if defined(__BORLANDC__)
+    struct timeb timebuffer;
+    ftime(&timebuffer);
+#  else
+    struct _timeb timebuffer;
+    _ftime(&timebuffer);
+#  endif
+    double utc = floor((double)timebuffer.time * 1000.0 + (double)timebuffer.millitm);
+#else
+    struct timeval tv;
+    gettimeofday(&tv, 0L);
+    double utc = floor((double)tv.tv_sec * 1000.0 + (double)tv.tv_usec / 1000.0);
+#endif
+    value = Number(utc);
+  } else if (numArgs == 1) {
+    UString s = args[0].toString(exec);
+    double d = s.toDouble();
+    if (isNaN(d))
+      value = parseDate(s);
+    else
+      value = Number(d);
+  } else {
+    struct tm t;
+    memset(&t, 0, sizeof(t));
+    Number y = args[0].toNumber(exec);
+    // TODO: check for NaN
+    int year = y.toInt32(exec);
+    t.tm_year = (year >= 0 && year <= 99) ? year : year - 1900;
+    t.tm_mon = args[1].toInt32(exec);
+    t.tm_mday = (numArgs >= 3) ? args[2].toInt32(exec) : 1;
+    t.tm_hour = (numArgs >= 4) ? args[3].toInt32(exec) : 0;
+    t.tm_min = (numArgs >= 5) ? args[4].toInt32(exec) : 0;
+    t.tm_sec = (numArgs >= 6) ? args[5].toInt32(exec) : 0;
+    t.tm_isdst = -1;
+    int ms = (numArgs >= 7) ? args[6].toInt32(exec) : 0;
+    value = Number(mktime(&t) * 1000.0 + ms);
+  }
+
+  Object proto = exec->interpreter()->builtinDatePrototype();
+  Object ret(new DateInstanceImp(proto));
+  ret.setInternalValue(timeClip(value));
+  return ret;
+}
+
+bool DateObjectImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.9.2
+Value DateObjectImp::call(ExecState */*exec*/, Object &/*thisObj*/, const List &/*args*/)
+{
+#ifdef KJS_VERBOSE
+  fprintf(stderr,"DateObjectImp::call - current time\n");
+#endif
+  time_t t = time(0L);
+  UString s(ctime(&t));
+
+  // return formatted string minus trailing \n
+  return String(s.substr(0, s.size() - 1));
+}
+
+// ------------------------------ DateObjectFuncImp ----------------------------
+
+DateObjectFuncImp::DateObjectFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                                     int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+bool DateObjectFuncImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.9.4.2 - 3
+Value DateObjectFuncImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  if (id == Parse) {
+    if (args[0].type() == StringType)
+      return parseDate(args[0].toString(exec));
+    else
+      return Undefined();
+  }
+  else { // UTC
+    struct tm t;
+    memset(&t, 0, sizeof(t));
+    int n = args.size();
+    Number y = args[0].toNumber(exec);
+    // TODO: check for NaN
+    int year = y.toInt32(exec);
+    t.tm_year = (year >= 0 && year <= 99) ? year : year - 1900;
+    t.tm_mon = args[1].toInt32(exec);
+    t.tm_mday = (n >= 3) ? args[2].toInt32(exec) : 1;
+    t.tm_hour = (n >= 4) ? args[3].toInt32(exec) : 0;
+    t.tm_min = (n >= 5) ? args[4].toInt32(exec) : 0;
+    t.tm_sec = (n >= 6) ? args[5].toInt32(exec) : 0;
+    int ms = (n >= 7) ? args[6].toInt32(exec) : 0;
+    return Number(mktime(&t) * 1000.0 + ms);
+  }
+}
+
+// -----------------------------------------------------------------------------
+
+
+Value KJS::parseDate(const String &s)
 {
   UString u = s.value();
+#ifdef KJS_VERBOSE
+  fprintf(stderr,"KJS::parseDate %s\n",u.ascii());
+#endif
   int firstSlash = u.find('/');
   if ( firstSlash == -1 )
   {
-    /* TODO parse dates like "December 25, 1995 23:15:00"*/
-    fprintf(stderr,"KJS::parseDate parsing for this format isn't implemented\n%s", u.ascii());
-    return Number(0);
+    time_t seconds = KRFCDate_parseDate( u );
+#ifdef KJS_VERBOSE
+    fprintf(stderr,"KRFCDate_parseDate returned seconds=%d\n",seconds);
+#endif
+    if ( seconds == -1 )
+      return Undefined();
+    else
+      return Number(seconds * 1000.0);
   }
   else
@@ -127 +504 @@
 }
 
-KJSO KJS::timeClip(const KJSO &t)
+///// Awful duplication from krfcdate.cpp - we don't link to kdecore
+
+static unsigned int ymdhms_to_seconds(int year, int mon, int day, int hour, int minute, int second)
+{
+    unsigned int ret = (day - 32075)       /* days */
+            + 1461L * (year + 4800L + (mon - 14) / 12) / 4
+            + 367 * (mon - 2 - (mon - 14) / 12 * 12) / 12
+            - 3 * ((year + 4900L + (mon - 14) / 12) / 100) / 4
+            - 2440588;
+    ret = 24*ret + hour;     /* hours   */
+    ret = 60*ret + minute;   /* minutes */
+    ret = 60*ret + second;   /* seconds */
+
+    return ret;
+}
+
+static const char haystack[37]="janfebmaraprmayjunjulaugsepoctnovdec";
+
+// we follow the recommendation of rfc2822 to consider all
+// obsolete time zones not listed here equivalent to "-0000"
+static const struct {
+    const char *tzName;
+    int tzOffset;
+} known_zones[] = {
+    { "UT", 0 },
+    { "GMT", 0 },
+    { "EST", -300 },
+    { "EDT", -240 },
+    { "CST", -360 },
+    { "CDT", -300 },
+    { "MST", -420 },
+    { "MDT", -360 },
+    { "PST", -480 },
+    { "PDT", -420 },
+    { 0, 0 }
+};
+
+time_t KJS::KRFCDate_parseDate(const UString &_date)
+{
+     // This parse a date in the form:
+     //     Wednesday, 09-Nov-99 23:12:40 GMT
+     // or
+     //     Sat, 01-Jan-2000 08:00:00 GMT
+     // or
+     //     Sat, 01 Jan 2000 08:00:00 GMT
+     // or
+     //     01 Jan 99 22:00 +0100    (exceptions in rfc822/rfc2822)
+     // ### non RFC format, added for Javascript:
+     //     [Wednesday] January 09 1999 23:12:40 GMT
+     //
+     // We ignore the weekday
+     //
+     time_t result = 0;
+     int offset = 0;
+     char *newPosStr;
+     const char *dateString = _date.ascii();
+     int day = 0;
+     char monthStr[4];
+     int month = -1; // not set yet
+     int year = 0;
+     int hour = 0;
+     int minute = 0;
+     int second = 0;
+
+     // Skip leading space
+     while(*dateString && isspace(*dateString))
+        dateString++;
+
+     const char *wordStart = dateString;
+     // Check contents of first words if not number
+     while(*dateString && !isdigit(*dateString))
+     {
+        if ( isspace(*dateString) && dateString - wordStart >= 3 )
+        {
+          monthStr[0] = tolower(*wordStart++);
+          monthStr[1] = tolower(*wordStart++);
+          monthStr[2] = tolower(*wordStart++);
+          monthStr[3] = '\0';
+          //fprintf(stderr,"KJS::parseDate found word starting with '%s'\n", monthStr);
+          const char *str = strstr(haystack, monthStr);
+          if (str)
+            month = (str-haystack)/3; // Jan=00, Feb=01, Mar=02, ..
+          while(*dateString && isspace(*dateString))
+             dateString++;
+          wordStart = dateString;
+        }
+        else
+           dateString++;
+     }
+
+     while(*dateString && isspace(*dateString))
+        dateString++;
+
+     if (!*dateString)
+        return result;  // Invalid date
+
+     // ' 09-Nov-99 23:12:40 GMT'
+     day = strtol(dateString, &newPosStr, 10);
+     dateString = newPosStr;
+
+     if ((day < 1) || (day > 31))
+        return result; // Invalid date;
+     if (!*dateString)
+        return result;  // Invalid date
+
+     if (*dateString == '-')
+        dateString++;
+
+     while(*dateString && isspace(*dateString))
+        dateString++;
+
+     if ( month == -1 ) // not found yet
+     {
+        for(int i=0; i < 3;i++)
+        {
+           if (!*dateString || (*dateString == '-') || isspace(*dateString))
+              return result;  // Invalid date
+           monthStr[i] = tolower(*dateString++);
+        }
+        monthStr[3] = '\0';
+
+        newPosStr = (char*)strstr(haystack, monthStr);
+
+        if (!newPosStr)
+           return result;  // Invalid date
+
+        month = (newPosStr-haystack)/3; // Jan=00, Feb=01, Mar=02, ..
+
+        if ((month < 0) || (month > 11))
+           return result;  // Invalid date
+
+        while(*dateString && (*dateString != '-') && !isspace(*dateString))
+           dateString++;
+
+        if (!*dateString)
+           return result;  // Invalid date
+
+        // '-99 23:12:40 GMT'
+        if ((*dateString != '-') && !isspace(*dateString))
+           return result;  // Invalid date
+        dateString++;
+     }
+
+     if ((month < 0) || (month > 11))
+        return result;  // Invalid date
+
+     // '99 23:12:40 GMT'
+     year = strtol(dateString, &newPosStr, 10);
+     dateString = newPosStr;
+
+     // Y2K: Solve 2 digit years
+     if ((year >= 0) && (year < 50))
+         year += 2000;
+
+     if ((year >= 50) && (year < 100))
+         year += 1900;  // Y2K
+
+     if ((year < 1900) || (year > 2500))
+        return result; // Invalid date
+
+     // Don't fail if the time is missing.
+     if (*dateString)
+     {
+        // ' 23:12:40 GMT'
+        if (!isspace(*dateString++))
+           return result;  // Invalid date
+
+        hour = strtol(dateString, &newPosStr, 10);
+        dateString = newPosStr;
+
+        if ((hour < 0) || (hour > 23))
+           return result; // Invalid date
+
+        if (!*dateString)
+           return result;  // Invalid date
+
+        // ':12:40 GMT'
+        if (*dateString++ != ':')
+           return result;  // Invalid date
+
+        minute = strtol(dateString, &newPosStr, 10);
+        dateString = newPosStr;
+
+        if ((minute < 0) || (minute > 59))
+           return result; // Invalid date
+
+        if (!*dateString)
+           return result;  // Invalid date
+
+        // ':40 GMT'
+        if (*dateString != ':' && !isspace(*dateString))
+           return result;  // Invalid date
+
+        // seconds are optional in rfc822 + rfc2822
+        if (*dateString ==':') {
+           dateString++;
+
+           second = strtol(dateString, &newPosStr, 10);
+           dateString = newPosStr;
+
+           if ((second < 0) || (second > 59))
+              return result; // Invalid date
+        } else {
+           dateString++;
+        }
+
+        while(*dateString && isspace(*dateString))
+           dateString++;
+     }
+
+     // don't fail if the time zone is missing, some
+     // broken mail-/news-clients omit the time zone
+     if (*dateString) {
+
+        if ((*dateString == '+') || (*dateString == '-')) {
+           offset = strtol(dateString, &newPosStr, 10);
+
+           if ((offset < -9959) || (offset > 9959))
+              return result; // Invalid date
+
+           int sgn = (offset < 0)? -1:1;
+           offset = abs(offset);
+           offset = ((offset / 100)*60 + (offset % 100))*sgn;
+        } else {
+           for (int i=0; known_zones[i].tzName != 0; i++) {
+              if (0 == strncasecmp(dateString, known_zones[i].tzName, strlen(known_zones[i].tzName))) {
+                 offset = known_zones[i].tzOffset;
+                 break;
+              }
+           }
+        }
+     }
+     if (sizeof(time_t) == 4)
+     {
+         if ((time_t)-1 < 0)
+         {
+            if (year >= 2038)
+            {
+               year = 2038;
+               month = 0;
+               day = 1;
+               hour = 0;
+               minute = 0;
+               second = 0;
+            }
+         }
+         else
+         {
+            if (year >= 2115)
+            {
+               year = 2115;
+               month = 0;
+               day = 1;
+               hour = 0;
+               minute = 0;
+               second = 0;
+            }
+         }
+     }
+
+     result = ymdhms_to_seconds(year, month+1, day, hour, minute, second);
+
+     // avoid negative time values
+     if ((offset > 0) && (offset > result))
+        offset = 0;
+
+     result -= offset*60;
+
+     // If epoch 0 return epoch +1 which is Thu, 01-Jan-70 00:00:01 GMT
+     // This is so that parse error and valid epoch 0 return values won't
+     // be the same for sensitive applications...
+     if (result < 1) result = 1;
+
+     return result;
+}
+
+
+Value KJS::timeClip(const Value &t)
 {
   /* TODO */
@@ -133 +787 @@
 }
 
-DateObject::DateObject(const Object& funcProto, const Object &dateProto)
-    : ConstructorImp(funcProto, 7)
-{
-  // ECMA 15.9.4.1 Date.prototype
-  setPrototypeProperty(dateProto);
-}
-
-// ECMA 15.9.2
-Completion DateObject::execute(const List &)
-{
-  time_t t = time(0L);
-  UString s(ctime(&t));
-
-  // return formatted string minus trailing \n
-  return Completion(ReturnValue, String(s.substr(0, s.size() - 1)));
-}
-
-// ECMA 15.9.3
-Object DateObject::construct(const List &args)
-{
-  KJSO value;
-
-  int numArgs = args.size();
-
-  if (numArgs == 0) { // new Date() ECMA 15.9.3.3
-#if HAVE_SYS_TIMEB_H
-#  if defined(__BORLANDC__)
-    struct timeb timebuffer;
-    ftime(&timebuffer);
-#  else
-    struct _timeb timebuffer;
-    _ftime(&timebuffer);
-#  endif
-    double utc = floor((double)timebuffer.time * 1000.0 + (double)timebuffer.millitm);
-#else
-    struct timeval tv;
-    gettimeofday(&tv, 0L);
-    double utc = floor((double)tv.tv_sec * 1000.0 + (double)tv.tv_usec / 1000.0);
-#endif
-    value = Number(utc);
-  } else if (numArgs == 1) {
-    KJSO p = args[0].toPrimitive();
-    if (p.isA(StringType))
-      value = parseDate(p.toString());
-    else
-      value = p.toNumber();
-  } else {
-    struct tm t;
-    memset(&t, 0, sizeof(t));
-    Number y = args[0].toNumber();
-    /* TODO: check for NaN */
-    int year = y.toInt32();
-    t.tm_year = (year >= 0 && year <= 99) ? year : year - 1900;
-    t.tm_mon = args[1].toInt32();
-    t.tm_mday = (numArgs >= 3) ? args[2].toInt32() : 1;
-    t.tm_hour = (numArgs >= 4) ? args[3].toInt32() : 0;
-    t.tm_min = (numArgs >= 5) ? args[4].toInt32() : 0;
-    t.tm_sec = (numArgs >= 6) ? args[5].toInt32() : 0;
-    t.tm_isdst = -1;
-    int ms = (numArgs >= 7) ? args[6].toInt32() : 0;
-    value = Number(mktime(&t) * 1000.0 + ms);
-  }
-
-  return Object::create(DateClass, timeClip(value));
-}
-
-KJSO DateObject::get(const UString &p) const
-{
-  int id;
-
-  if (p == "parse")
-    id = DateObjectFunc::Parse;
-  else if (p == "UTC")
-    id = DateObjectFunc::UTC;
-  else
-    return Imp::get(p);
-
-  return Function(new DateObjectFunc(id));
-}
-
-// ECMA 15.9.4.2 - 3
-Completion DateObjectFunc::execute(const List &args)
-{
-  KJSO result;
-
-  if (id == Parse)
-    if (args[0].isA(StringType))
-      result = parseDate(args[0].toString());
-    else
-      result = Undefined();
-  else {
-    struct tm t;
-    memset(&t, 0, sizeof(t));
-    int n = args.size();
-    Number y = args[0].toNumber();
-    /* TODO: check for NaN */
-    int year = y.toInt32();
-    t.tm_year = (year >= 0 && year <= 99) ? year : year - 1900;
-    t.tm_mon = args[1].toInt32();
-    t.tm_mday = (n >= 3) ? args[2].toInt32() : 1;
-    t.tm_hour = (n >= 4) ? args[3].toInt32() : 0;
-    t.tm_min = (n >= 5) ? args[4].toInt32() : 0;
-    t.tm_sec = (n >= 6) ? args[5].toInt32() : 0;
-    int ms = (n >= 7) ? args[6].toInt32() : 0;
-    result = Number(mktime(&t) * 1000.0 + ms);
-  }
-
-  return Completion(ReturnValue, result);
-}
-
-// ECMA 15.9.4
-DatePrototype::DatePrototype(const Object& proto)
-  : ObjectImp(DateClass, Number(NaN), proto)
-{
-  // The constructor will be added later in DateObject's constructor
-}
-
-KJSO DatePrototype::get(const UString &p) const
-{
-  int id;
-
-  if (p == "toString" || p == "toUTCString")
-    id = DateProtoFunc::ToString;
-  else if (p == "toDateString")
-    id = DateProtoFunc::ToDateString;
-  else if (p == "toTimeString")
-    id = DateProtoFunc::ToTimeString;
-  else if (p == "toLocaleString")
-    id = DateProtoFunc::ToLocaleString;
-  else if (p == "toLocaleDateString")
-    id = DateProtoFunc::ToLocaleDateString;
-  else if (p == "toLocaleTimeString")
-    id = DateProtoFunc::ToLocaleTimeString;
-  else if (p == "valueOf")
-    id = DateProtoFunc::ValueOf;
-  else if (p == "getTime")
-    id = DateProtoFunc::GetTime;
-  else if (p == "getFullYear" || p == "getUTCFullYear")
-    id = DateProtoFunc::GetFullYear;
-  else if (p == "toGMTString")
-    id = DateProtoFunc::ToGMTString;
-  else if (p == "getMonth" || p == "getUTCMonth")
-    id = DateProtoFunc::GetMonth;
-  else if (p == "getDate" || p == "getUTCDate")
-    id = DateProtoFunc::GetDate;
-  else if (p == "getDay" || p == "getUTCDay")
-    id = DateProtoFunc::GetDay;
-  else if (p == "getHours" || p == "getUTCHours")
-    id = DateProtoFunc::GetHours;
-  else if (p == "getMinutes" || p == "getUTCMinutes")
-    id = DateProtoFunc::GetMinutes;
-  else if (p == "getSeconds" || p == "getUTCSeconds")
-    id = DateProtoFunc::GetSeconds;
-  else if (p == "getMilliseconds" || p == "getUTCMilliseconds")
-    id = DateProtoFunc::GetMilliSeconds;
-  else if (p == "getTimezoneOffset")
-    id = DateProtoFunc::GetTimezoneOffset;
-  else if (p == "setTime")
-    id = DateProtoFunc::SetTime;
-  else if (p == "setMilliseconds" || p == "setUTCMilliseconds")
-    id = DateProtoFunc::SetMilliSeconds;
-  else if (p == "setSeconds" || p == "setUTCSeconds")
-    id = DateProtoFunc::SetSeconds;
-  else if (p == "setMinutes" || p == "setUTCMinutes")
-    id = DateProtoFunc::SetMinutes;
-  else if (p == "setHours" || p == "setUTCHours")
-    id = DateProtoFunc::SetHours;
-  else if (p == "setDate" || p == "setUTCDate")
-    id = DateProtoFunc::SetDate;
-  else if (p == "setMonth" || p == "setUTCMonth")
-    id = DateProtoFunc::SetMonth;
-  else if (p == "setFullYear" || p == "setUTCFullYear")
-    id = DateProtoFunc::SetFullYear;
-  else if (p == "setYear" )
-    id = DateProtoFunc::SetYear;
-  // non-normative
-  else if (p == "getYear")
-    id = DateProtoFunc::GetYear;
-  else if (p == "toGMTString")
-    id = DateProtoFunc::ToGMTString;
-  else
-    return Undefined();
-
-  bool utc = (p.find("UTC") >= 0) ? true : false;
-  return Function(new DateProtoFunc(id, utc));
-}
-
-DateProtoFunc::DateProtoFunc(int i, bool u) : id(i), utc(u)
-{
-}
-
-Completion DateProtoFunc::execute(const List &args)
-{
-  KJSO result;
-  UString s;
-  const int bufsize=100;
-  char timebuffer[bufsize];
-  char *oldlocale = setlocale(LC_TIME,NULL);
-  if (!oldlocale)
-    oldlocale = setlocale(LC_ALL, NULL);
-  Object thisObj = Object::dynamicCast(thisValue());
-  KJSO v = thisObj.internalValue();
-  double milli = v.toNumber().value();
-  time_t tv = (time_t) floor(milli / 1000.0);
-  int ms = int(milli - tv * 1000.0);
-
-  struct tm *t;
-  if (utc)
-    t = gmtime(&tv);
-  else
-    t = localtime(&tv);
-
-  switch (id) {
-  case ToString:
-    s = ctime(&tv);
-    result = String(s.substr(0, s.size() - 1));
-    break;
-  case ToDateString:
-  case ToTimeString:
-  case ToGMTString:
-    setlocale(LC_TIME,"C");
-    if (id == DateProtoFunc::ToDateString) {
-      strftime(timebuffer, bufsize, "%x",t);
-    } else if (id == DateProtoFunc::ToTimeString) {
-      strftime(timebuffer, bufsize, "%X",t);
-    } else {
-      t = gmtime(&tv);
-      strftime(timebuffer, bufsize, "%a, %d-%b-%y %H:%M:%S %Z", t);
-    }
-    setlocale(LC_TIME,oldlocale);
-    result = String(timebuffer);
-    break;
-  case ToLocaleString:
-    strftime(timebuffer, bufsize, "%c", t);
-    result = String(timebuffer);
-    break;
-  case ToLocaleDateString:
-    strftime(timebuffer, bufsize, "%x", t);
-    result = String(timebuffer);
-    break;
-  case ToLocaleTimeString:
-    strftime(timebuffer, bufsize, "%X", t);
-    result = String(timebuffer);
-    break;
-  case ValueOf:
-    result = Number(milli);
-    break;
-  case GetTime:
-    if (thisObj.getClass() == DateClass)
-      result = Number(milli);
-    else
-      result = Error::create(TypeError);
-    break;
-  case GetYear:
-    result = Number(t->tm_year);
-    break;
-  case GetFullYear:
-    result = Number(1900 + t->tm_year);
-    break;
-  case GetMonth:
-    result = Number(t->tm_mon);
-    break;
-  case GetDate:
-    result = Number(t->tm_mday);
-    break;
-  case GetDay:
-    result = Number(t->tm_wday);
-    break;
-  case GetHours:
-    result = Number(t->tm_hour);
-    break;
-  case GetMinutes:
-    result = Number(t->tm_min);
-    break;
-  case GetSeconds:
-    result = Number(t->tm_sec);
-    break;
-  case GetMilliSeconds:
-    result = Undefined();
-    break;
-  case GetTimezoneOffset:
-#if defined BSD || defined(__APPLE__)
-    result = Number(-( t->tm_gmtoff / 60 ) + ( t->tm_isdst ? 60 : 0 ));
-#else
-#  if defined(__BORLANDC__)
-#error please add daylight savings offset here!
-    result = Number(_timezone / 60 - (_daylight ? 60 : 0));
-#  else
-    result = Number(( timezone / 60 - ( daylight ? 60 : 0 )));
-#  endif
-#endif
-    break;
-  case SetTime:
-    milli = args[0].round();
-    result = Number(milli);
-    thisObj.setInternalValue(result);
-    break;
-  case SetMilliSeconds:
-    ms = args[0].toInt32();
-    break;
-  case SetSeconds:
-    t->tm_sec = args[0].toInt32();
-    break;
-  case SetMinutes:
-    t->tm_min = args[0].toInt32();
-    break;
-  case SetHours:
-    t->tm_hour = args[0].toInt32();
-    break;
-  case SetDate:
-    t->tm_mday = args[0].toInt32();
-    break;
-  case SetMonth:
-    t->tm_mon = args[0].toInt32();
-    break;
-  case SetFullYear:
-    t->tm_year = args[0].toInt32() - 1900;
-    break;
-  case SetYear:
-    t->tm_year = args[0].toInt32() >= 1900 ? args[0].toInt32() - 1900 : args[0].toInt32();
-    break;
-  }
-
-  if (id == SetYear || id == SetMilliSeconds || id == SetSeconds ||
-      id == SetMinutes || id == SetHours || id == SetDate ||
-      id == SetMonth || id == SetFullYear ) {
-    result = Number(mktime(t) * 1000.0 + ms);
-    thisObj.setInternalValue(result);
-  }
-
-  return Completion(ReturnValue, result);
-}

trunk/JavaScriptCore/kjs/date_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _DATE_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class DateObject : public ConstructorImp {
+  class DateInstanceImp : public ObjectImp {
   public:
-    DateObject(const Object& funcProto, const Object &dateProto);
+    DateInstanceImp(const Object &proto);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  };
+
+  /**
+   * @internal
+   *
+   * The initial value of Date.prototype (and thus all objects created
+   * with the Date constructor
+   */
+  class DatePrototypeImp : public DateInstanceImp {
+  public:
+    DatePrototypeImp(ExecState *exec, ObjectPrototypeImp *objectProto);
+    Value get(ExecState *exec, const UString &p) const;
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  };
+
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * Date.prototype object
+   */
+  class DateProtoFuncImp : public InternalFunctionImp {
+  public:
+    DateProtoFuncImp(ExecState *exec, int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+
+    Completion execute(const List &);
+    enum { ToString, ToDateString, ToTimeString, ToLocaleString,
+           ToLocaleDateString, ToLocaleTimeString, ValueOf, GetTime,
+           GetFullYear, GetMonth, GetDate, GetDay, GetHours, GetMinutes,
+           GetSeconds, GetMilliSeconds, GetTimezoneOffset, SetTime,
+           SetMilliSeconds, SetSeconds, SetMinutes, SetHours, SetDate,
+           SetMonth, SetFullYear, ToUTCString,
+           // non-normative properties (Appendix B)
+           GetYear, SetYear, ToGMTString };
+  private:
+    int id;
+    bool utc;
+  };
+
+  /**
+   * @internal
+   *
+   * The initial value of the the global variable's "Date" property
+   */
+  class DateObjectImp : public InternalFunctionImp {
+  public:
+    DateObjectImp(ExecState *exec,
+                  FunctionPrototypeImp *funcProto,
+                  DatePrototypeImp *dateProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
     Completion execute(const List &);
     Object construct(const List &);
-    KJSO get(const UString &p) const;
   };
 
-  class DatePrototype : public ObjectImp {
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * Date object
+   */
+  class DateObjectFuncImp : public InternalFunctionImp {
   public:
-    DatePrototype(const Object& proto);
-    virtual KJSO get(const UString &p) const;
+    DateObjectFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                      int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    enum { Parse, UTC };
+  private:
+    int id;
   };
+
+  // helper functions
+  Value parseDate(const String &s);
+  time_t KRFCDate_parseDate(const UString &_date);
+  Value timeClip(const Value &t);
 
 }; // namespace

trunk/JavaScriptCore/kjs/debugger.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -16 +18 @@
  *  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$
  */
 
-#ifdef KJS_DEBUGGER
-
 #include "debugger.h"
-#include "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "internal.h"
 #include "ustring.h"
@@ -27 +32 @@
 using namespace KJS;
 
-Debugger::Debugger(KJScript *engine)
-  : eng(0L),
-    sid(-1)
+// ------------------------------ Debugger -------------------------------------
+
+namespace KJS {
+  struct AttachedInterpreter
+  {
+  public:
+    AttachedInterpreter(Interpreter *i) : interp(i) {}
+    Interpreter *interp;
+    AttachedInterpreter *next;
+  };
+
+}
+
+Debugger::Debugger()
 {
-  attach(engine);
+  rep = new DebuggerImp();
 }
 
 Debugger::~Debugger()
 {
-  detach();
+  // detach from all interpreters
+  while (rep->interps)
+    detach(rep->interps->interp);
+
+  delete rep;
 }
 
-void Debugger::attach(KJScript *e)
+void Debugger::attach(Interpreter *interp)
 {
-  dmode = Disabled;
-  if (e) {
-    if (!eng || e->rep != eng->rep) {
-      eng = e;
-      eng->rep->attachDebugger(this);
-    }
-  } else {
-    eng = 0L;
+  if (interp->imp()->debugger() != this)
+    interp->imp()->setDebugger(this);
+
+  // add to the list of attached interpreters
+  if (!rep->interps)
+    rep->interps = new AttachedInterpreter(interp);
+  else {
+    AttachedInterpreter *ai = rep->interps;
+    while (ai->next)
+      ai = ai->next;
+    ai->next = new AttachedInterpreter(interp);;
   }
-  reset();
 }
 
-KJScript *Debugger::engine() const
+void Debugger::detach(Interpreter *interp)
 {
-  return eng;
+  if (interp->imp()->debugger() == this)
+    interp->imp()->setDebugger(this);
+
+  // remove from the list of attached interpreters
+  if (rep->interps->interp == interp) {
+    AttachedInterpreter *old = rep->interps;
+    rep->interps = rep->interps->next;
+    delete old;
+  }
+
+  AttachedInterpreter *ai = rep->interps;
+  while (ai->next && ai->next->interp != interp)
+    ai = ai->next;
+  if (ai->next) {
+    AttachedInterpreter *old = ai->next;
+    ai->next = ai->next->next;
+    delete old;
+  }
 }
 
-void Debugger::detach()
-{
-  reset();
-  if (!eng)
-    return;
-  eng->rep->attachDebugger(0L);
-  eng = 0L;
-}
-
-void Debugger::setMode(Mode m)
-{
-  dmode = m;
-}
-
-Debugger::Mode Debugger::mode() const
-{
-  return dmode;
-}
-
-// supposed to be overriden by the user
-bool Debugger::stopEvent()
+bool Debugger::sourceParsed(ExecState */*exec*/, int /*sourceId*/,
+                            const UString &/*source*/, int /*errorLine*/)
 {
   return true;
 }
 
-void Debugger::callEvent(const UString &, const UString &)
+bool Debugger::sourceUnused(ExecState */*exec*/, int /*sourceId*/)
 {
+  return true;
 }
 
-void Debugger::returnEvent()
+bool Debugger::exception(ExecState */*exec*/, int /*sourceId*/, int /*lineno*/,
+                         Object &/*exceptionObj*/)
 {
+  return true;
 }
 
-void Debugger::reset()
+bool Debugger::atStatement(ExecState */*exec*/, int /*sourceId*/, int /*firstLine*/,
+                           int /*lastLine*/)
 {
-  l = -1;
+  return true;
 }
 
-int Debugger::freeSourceId() const
+bool Debugger::callEvent(ExecState */*exec*/, int /*sourceId*/, int /*lineno*/,
+                         Object &/*function*/, const List &/*args*/)
 {
-  return eng ? eng->rep->sourceId()+1 : -1;
+  return true;
 }
 
-bool Debugger::setBreakpoint(int id, int line)
+bool Debugger::returnEvent(ExecState */*exec*/, int /*sourceId*/, int /*lineno*/,
+                           Object &/*function*/)
 {
-  if (!eng)
-    return false;
-  return eng->rep->setBreakpoint(id, line, true);
+  return true;
 }
 
-bool Debugger::deleteBreakpoint(int id, int line)
-{
-  if (!eng)
-    return false;
-  return eng->rep->setBreakpoint(id, line, false);
-}
-
-void Debugger::clearAllBreakpoints(int id)
-{
-  if (!eng)
-    return;
-  eng->rep->setBreakpoint(id, -1, false);
-}
-
-UString Debugger::varInfo(const UString &ident)
-{
-  if (!eng)
-    return UString();
-
-  int dot = ident.find('.');
-  if (dot < 0)
-      dot = ident.size();
-  UString sub = ident.substr(0, dot);
-  KJSO obj;
-  // resolve base
-  if (sub == "this") {
-      obj = Context::current()->thisValue();
-  } else {
-      const List *chain = Context::current()->pScopeChain();
-      ListIterator scope = chain->begin();
-      while (scope != chain->end()) {
-          if (scope->hasProperty(ident)) {
-              obj = scope->get(ident);
-              break;
-          }
-          scope++;
-      }
-      if (scope == chain->end())
-        return UString();
-  }
-  // look up each part of a.b.c.
-  while (dot < ident.size()) {
-    int olddot = dot;
-    dot = ident.find('.', olddot+1);
-    if (dot < 0)
-      dot = ident.size();
-    sub = ident.substr(olddot+1, dot-olddot-1);
-    obj = obj.get(sub);
-    if (!obj.isDefined())
-      break;
-  }
-
-  return sub + "=" + objInfo(obj) + ":" + UString(obj.imp()->typeInfo()->name);
-}
-
-// called by varInfo() and recursively by itself on each properties
-UString Debugger::objInfo(const KJSO &obj) const
-{
-  const char *cnames[] = { "Undefined", "Array", "String", "Boolean",
-                           "Number", "Object", "Date", "RegExp",
-                           "Error", "Function" };
-  PropList *plist = obj.imp()->propList(0, 0, false);
-  if (!plist)
-    return obj.toString().value();
-  else {
-    UString result = "{";
-    while (1) {
-      result += plist->name + "=";
-      KJSO p = obj.get(plist->name);
-      result += objInfo(p) + ":";
-      Object obj = Object::dynamicCast(p);
-      if (obj.isNull())
-        result += p.imp()->typeInfo()->name;
-      else
-        result += cnames[int(obj.getClass())];
-      plist = plist->next;
-      if (!plist)
-        break;
-      result += ",";
-    }
-    result += "}";
-    return result;
-  }
-}
-
-bool Debugger::setVar(const UString &ident, const KJSO &value)
-{
-  if (!eng)
-    return false;
-  const List *chain = Context::current()->pScopeChain();
-  ListIterator scope = chain->begin();
-  while (scope != chain->end()) {
-    if (scope->hasProperty(ident)) {
-      if (!scope->canPut(ident))
-        return false;
-      scope->put(ident, value);
-      return true;
-    }
-    scope++;
-  }
-  // didn't find variable
-  return false;
-}
-
-// called from the scripting engine each time a statement node is hit.
-bool Debugger::hit(int line, bool breakPoint)
-{
-  l = line;
-  if (!eng)
-    return true;
-
-  if (!breakPoint && ( mode() == Continue || mode() == Disabled ) )
-      return true;
-
-  bool ret = stopEvent();
-  eng->init();  // in case somebody used a different interpreter meanwhile
-  return ret;
-}
-
-#endif

trunk/JavaScriptCore/kjs/debugger.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -16 +18 @@
  *  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$
  */
 
@@ -21 +25 @@
 #define _KJSDEBUGGER_H_
 
-#include "internal.h"
-
 namespace KJS {
 
-  //
-  // NOTE: this interface is not ready, yet. Do not use unless you
-  // don't mind source and binary incompatible changes that may arise
-  // before the final version is released.
-  //
-
-#ifdef KJS_DEBUGGER
+  class DebuggerImp;
+  class Interpreter;
+  class ExecState;
+  class Object;
+  class UString;
+  class List;
+
+  /**
+   * @internal
+   *
+   * Provides an interface which receives notification about various
+   * script-execution related events such as statement execution and function
+   * calls.
+   *
+   * WARNING: This interface is still a work in progress and is not yet
+   * offically publicly available. It is likely to change in binary incompatible
+   * (and possibly source incompatible) ways in future versions. It is
+   * anticipated that at some stage the interface will be frozen and made
+   * available for general use.
+   */
   class Debugger {
-    friend class KJScriptImp;
-    friend class StatementNode;
-    friend class DeclaredFunctionImp;
-    friend class FunctionImp;
   public:
-    /**
-     * Available modes of the debugger.
-     */
-    enum Mode { Disabled = 0, Next, Step, Continue, Stop };
-    /**
-     * Construct a debugger and attach it to the scripting engine s.
-     */
-    Debugger(KJScript *s);
-    /**
-     * Destruct the debugger and detach from the scripting engine we
-     * might have been attached to.
+
+    /**
+     * Creates a new debugger
+     */
+    Debugger();
+
+    /**
+     * Destroys the debugger. If the debugger is attached to any interpreters,
+     * it is automatically detached.
      */
     virtual ~Debugger();
-    /**
-     * Attaches the debugger to specified scripting engine.
-     */
-    void attach(KJScript *e);
-    /**
-     * Returns the engine the interpreter is currently attached to. Null
-     * if there isn't any.
-     */
-    KJScript* engine() const;
-    /**
-     * Detach the debugger from any scripting engine.
-     */
-    void detach();
-    /**
-     * Set debugger into specified mode. This will influence further behaviour
-     * if execution of the programm is started or continued.
-     */
-    virtual void setMode(Mode m);
-    /**
-     * Returns the current operation mode.
-     */
-    Mode mode() const;
-    /**
-     * Returns the line number the debugger currently has stopped at.
-     * -1 if the debugger is not in a break status.
-     */
-    int lineNumber() const { return l; }
-    /**
-     * Returns the source id the debugger currently has stopped at.
-     * -1 if the debugger is not in a break status.
-     */
-    int sourceId() const { return sid; }
-    /**
-     * Sets a breakpoint in the first statement where line lies in between
-     * the statements range. Returns true if sucessfull, false if no
-     * matching statement could be found.
-     */
-    bool setBreakpoint(int id, int line);
-    bool deleteBreakpoint(int id, int line);
-    void clearAllBreakpoints(int id=-1);
-    /**
-     * Returns the value of ident out of the current context in string form
-     */
-    UString varInfo(const UString &ident);
-    /**
-     * Set variable ident to value. Returns true if successful, false if
-     * the specified variable doesn't exist or isn't writable.
-     */
-    bool setVar(const UString &ident, const KJSO &value);
-
-  protected:
-    /**
-     * Invoked in case a breakpoint or the next statement is reached in step
-     * mode. The return value decides whether execution will continue. True
-     * denotes continuation, false an abortion, respectively.
-     *
-     * The default implementation does nothing. Overload this method if
-     * you want to process this event.
-     */
-    virtual bool stopEvent();
-    /**
-     * Returns an integer that will be assigned to the code passed
-     * next to one of the KJScript::evaluate() methods. It's basically
-     * a counter to will only be reset to 0 on KJScript::clear().
-     *
-     * This information is useful in case you evaluate multiple blocks of
-     * code containing some function declarations. Keep a map of source id/
-     * code pairs, query sourceId() in case of a stopEvent() and update
-     * your debugger window with the matching source code.
-     */
-    int freeSourceId() const;
-    /**
-     * Invoked on each function call. Use together with @ref returnEvent
+
+    DebuggerImp *imp() const { return rep; }
+
+    /**
+     * Attaches the debugger to specified interpreter. This will cause this
+     * object to receive notification of events from the interpreter.
+     *
+     * If the interpreter is deleted, the debugger will automatically be
+     * detached.
+     *
+     * Note: only one debugger can be attached to an interpreter at a time.
+     * Attaching another debugger to the same interpreter will cause the
+     * original debugger to be detached from that interpreter.
+     *
+     * @param interp The interpreter to attach to
+     *
+     * @see detach()
+     */
+    void attach(Interpreter *interp);
+
+    /**
+     * Detach the debugger from an interpreter
+     *
+     * @param interp The interpreter to detach from. If 0, the debugger will be
+     * detached from all interpreters to which it is attached.
+     *
+     * @see attach()
+     */
+    void detach(Interpreter *interp);
+
+    /**
+     * Called to notify the debugger that some javascript source code has
+     * been parsed. For calls to Interpreter::evaluate(), this will be called
+     * with the supplied source code before any other code is parsed.
+     * Other situations in which this may be called include creation of a
+     * function using the Function() constructor, or the eval() function.
+     *
+     * The default implementation does nothing. Override this method if
+     * you want to process this event.
+     *
+     * @param exec The current execution state
+     * @param sourceId The ID of the source code (corresponds to the
+     * sourceId supplied in other functions such as @ref atStatement()
+     * @param source The source code that was parsed
+     * @param errorLine The line number at which parsing encountered an
+     * error, or -1 if the source code was valid and parsed succesfully
+     * @return true if execution should be continue, false if it should
+     * be aborted
+     */
+    virtual bool sourceParsed(ExecState *exec, int sourceId,
+                              const UString &source, int errorLine);
+
+    /**
+     * Called when all functions/programs associated with a particular
+     * sourceId have been deleted. After this function has been called for
+     * a particular sourceId, that sourceId will not be used again.
+     *
+     * The default implementation does nothing. Override this method if
+     * you want to process this event.
+     *
+     * @param exec The current execution state
+     * @param sourceId The ID of the source code (corresponds to the
+     * sourceId supplied in other functions such as atLine()
+     * @return true if execution should be continue, false if it should
+     * be aborted
+     */
+    virtual bool sourceUnused(ExecState *exec, int sourceId);
+
+    /**
+     * Called when an exception is thrown during script execution.
+     *
+     * The default implementation does nothing. Override this method if
+     * you want to process this event.
+     *
+     * @param exec The current execution state
+     * @param sourceId The ID of the source code being executed
+     * @param lineno The line at which the error occurred
+     * @param exceptionObj The exception object
+     * @return true if execution should be continue, false if it should
+     * be aborted
+     */
+    virtual bool exception(ExecState *exec, int sourceId, int lineno,
+                           Object &exceptionObj);
+
+    /**
+     * Called when a line of the script is reached (before it is executed)
+     *
+     * The default implementation does nothing. Override this method if
+     * you want to process this event.
+     *
+     * @param exec The current execution state
+     * @param sourceId The ID of the source code being executed
+     * @param firstLine The starting line of the statement  that is about to be
+     * executed
+     * @param firstLine The ending line of the statement  that is about to be
+     * executed (usually the same as firstLine)
+     * @return true if execution should be continue, false if it should
+     * be aborted
+     */
+    virtual bool atStatement(ExecState *exec, int sourceId, int firstLine,
+                             int lastLine);
+    /**
+     * Called on each function call. Use together with @ref #returnEvent
      * if you want to keep track of the call stack.
-     */
-    virtual void callEvent(const UString &fn = UString::null,
-                                    const UString &s = UString::null);
-    /**
-     * Invoked on each function exit.
-     */
-    virtual void returnEvent();
+     *
+     * Note: This only gets called for functions that are declared in ECMAScript
+     * source code or passed to eval(), not for internal KJS or
+     * application-supplied functions.
+     *
+     * The default implementation does nothing. Override this method if
+     * you want to process this event.
+     *
+     * @param exec The current execution state
+     * @param sourceId The ID of the source code being executed
+     * @param lineno The line that is about to be executed
+     * @param function The function being called
+     * @param args The arguments that were passed to the function
+     * line is being executed
+     * @return true if execution should be continue, false if it should
+     * be aborted
+     */
+    virtual bool callEvent(ExecState *exec, int sourceId, int lineno,
+                           Object &function, const List &args);
+
+    /**
+     * Called on each function exit. The function being returned from is that
+     * which was supplied in the last callEvent().
+     *
+     * Note: This only gets called for functions that are declared in ECMAScript
+     * source code or passed to eval(), not for internal KJS or
+     * application-supplied functions.
+     *
+     * The default implementation does nothing. Override this method if
+     * you want to process this event.
+     *
+     * @param exec The current execution state
+     * @param sourceId The ID of the source code being executed
+     * @param lineno The line that is about to be executed
+     * @param function The function being called
+     * @return true if execution should be continue, false if it should
+     * be aborted
+     */
+    virtual bool returnEvent(ExecState *exec, int sourceId, int lineno,
+                             Object &function);
 
   private:
-    void reset();
-    bool hit(int line, bool breakPoint);
-    void setSourceId(int i) { sid = i; }
-    UString objInfo(const KJSO &obj) const;
-
-    KJScript *eng;
-    Mode dmode;
-    int l;
-    int sid;
+    DebuggerImp *rep;
   };
+
+};
+
 #endif
-
-};
-
-#endif

trunk/JavaScriptCore/kjs/error_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
+ *
  */
 
-#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 "error_object.h"
-#include "debugger.h"
+//#include "debugger.h"
 
 using namespace KJS;
 
-const char *ErrorObject::errName[] = {
-  "No Error",
-  "Error",
-  "EvalError",
-  "RangeError",
-  "ReferenceError",
-  "SyntaxError",
-  "TypeError",
-  "URIError"
-};
+// ------------------------------ ErrorPrototypeImp ----------------------------
 
-ErrorObject::ErrorObject(const Object &funcProto, const Object &errProto,
-                         ErrorType t)
-  : ConstructorImp(funcProto, 1), errType(t)
+// ECMA 15.9.4
+ErrorPrototypeImp::ErrorPrototypeImp(ExecState *exec,
+                                     ObjectPrototypeImp *objectProto,
+                                     FunctionPrototypeImp *funcProto)
+  : ObjectImp(Object(objectProto))
 {
-  // ECMA 15.11.3.1 Error.prototype
-  setPrototypeProperty(errProto);
-  const char *n = errName[errType];
+  Value protect(this);
+  setInternalValue(Undefined());
+  // The constructor will be added later in ErrorObjectImp's constructor
 
-  put("name", String(n));
+  put(exec, "name",     String("Error"), DontEnum);
+  put(exec, "message",  String("Unknown error"), DontEnum);
+  put(exec, "toString", Object(new ErrorProtoFuncImp(exec,funcProto)), DontEnum);
 }
 
-ErrorObject::ErrorObject(const Object& proto, ErrorType t,
-                         const char *m, int l)
-  : ConstructorImp(proto, 1), errType(t)
+// ------------------------------ ErrorProtoFuncImp ----------------------------
+
+ErrorProtoFuncImp::ErrorProtoFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto)
+  : InternalFunctionImp(funcProto)
 {
-  const char *n = errName[errType];
-
-  put("name", String(n));
-  put("message", String(m));
-  put("line", Number(l));
-#ifdef KJS_DEBUGGER
-  Debugger *dbg = KJScriptImp::current()->debugger();
-  if (dbg)
-    put("sid", Number(dbg->sourceId()));
-#endif
+  Value protect(this);
+  put(exec,"length",Number(0),DontDelete|ReadOnly|DontEnum);
 }
 
-// ECMA 15.9.2
-Completion ErrorObject::execute(const List &args)
+bool ErrorProtoFuncImp::implementsCall() const
 {
-  // "Error()" gives the sames result as "new Error()"
-  return Completion(ReturnValue, construct(args));
+  return true;
 }
 
-// ECMA 15.9.3
-Object ErrorObject::construct(const List &args)
+Value ErrorProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &/*args*/)
 {
-  if (args.isEmpty() == 1 || !args[0].isDefined())
-    return Object::create(ErrorClass, Undefined());
+  // toString()
+  UString s = "Error";
 
-  String message = args[0].toString();
-  return Object::create(ErrorClass, message);
-}
+  Value v = thisObj.get(exec,"name");
+  if (v.type() != UndefinedType) {
+    s = v.toString(exec);
+  }
 
-Object ErrorObject::create(ErrorType e, const char *m, int l)
-{
-  Global global(Global::current());
-  KJSO prot = Global::current().get("[[Error.prototype]]");
-  assert(prot.isObject());
-  Imp *d = new ErrorObject(Object(prot.imp()), e, m, l);
-
-  return Object(d);
-}
-
-// ECMA 15.9.4
-ErrorPrototype::ErrorPrototype(const Object& proto)
-  : ObjectImp(ErrorClass, Undefined(), proto)
-{
-  // The constructor will be added later in ErrorObject's constructor
-}
-
-KJSO ErrorPrototype::get(const UString &p) const
-{
-  const char *s;
-
-  /* TODO: are these properties dynamic, i.e. should we put() them ? */
-  if (p == "name")
-    s = "Error";
-  else if (p == "message")
-    s = "Error message.";
-  else if (p == "toString")
-    return Function(new ErrorProtoFunc());
-  else
-    return Imp::get(p);
+  v = thisObj.get(exec,"message");
+  if (v.type() != UndefinedType) {
+    s += ": "+v.toString(exec);
+  }
 
   return String(s);
 }
 
-Completion ErrorProtoFunc::execute(const List &)
+// ------------------------------ ErrorObjectImp -------------------------------
+
+ErrorObjectImp::ErrorObjectImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                               ErrorPrototypeImp *errorProto)
+  : InternalFunctionImp(funcProto)
 {
-  // toString()
-  const char *s = "Error message.";
-
-  return Completion(ReturnValue, String(s));
+  Value protect(this);
+  // ECMA 15.11.3.1 Error.prototype
+  put(exec, "prototype", Object(errorProto), DontEnum|DontDelete|ReadOnly);
+  //put(exec, "name", String(n));
 }
 
+bool ErrorObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 15.9.3
+Object ErrorObjectImp::construct(ExecState *exec, const List &args)
+{
+  Object proto = Object::dynamicCast(exec->interpreter()->builtinErrorPrototype());
+  Object obj(new ObjectImp(proto));
+
+  if (!args.isEmpty() && args[0].type() != UndefinedType) {
+    obj.put(exec,"message", String(args[0].toString(exec)));
+  }
+
+  return obj;
+}
+
+bool ErrorObjectImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.9.2
+Value ErrorObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  // "Error()" gives the sames result as "new Error()"
+  return construct(exec,args);
+}
+
+// ------------------------------ NativeErrorPrototypeImp ----------------------
+
+NativeErrorPrototypeImp::NativeErrorPrototypeImp(ExecState *exec, ErrorPrototypeImp *errorProto,
+                                                 ErrorType et, UString name, UString message)
+  : ObjectImp(Object(errorProto))
+{
+  Value protect(this);
+  errType = et;
+  put(exec,"name",String(name));
+  put(exec,"message",String(message));
+}
+
+// ------------------------------ NativeErrorImp -------------------------------
+
+const ClassInfo NativeErrorImp::info = {"Error", &InternalFunctionImp::info, 0, 0};
+
+NativeErrorImp::NativeErrorImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                               const Object &prot)
+  : InternalFunctionImp(funcProto), proto(0)
+{
+  Value protect(this);
+  proto = static_cast<ObjectImp*>(prot.imp());
+
+  put(exec,"length",Number(1),DontDelete|ReadOnly|DontEnum); // ECMA 15.11.7.5
+  put(exec,"prototype",prot);
+}
+
+bool NativeErrorImp::implementsConstruct() const
+{
+  return true;
+}
+
+Object NativeErrorImp::construct(ExecState *exec, const List &args)
+{
+  Object obj(new ObjectImp(Object(proto)));
+  if (args[0].type() != UndefinedType)
+    obj.put(exec, "message", String(args[0].toString(exec)));
+  return obj;
+}
+
+bool NativeErrorImp::implementsCall() const
+{
+  return true;
+}
+
+Value NativeErrorImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  return construct(exec,args);
+}
+
+void NativeErrorImp::mark()
+{
+  ObjectImp::mark();
+  if (proto && !proto->marked())
+    proto->mark();
+}
+

trunk/JavaScriptCore/kjs/error_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _ERROR_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class ErrorObject : public ConstructorImp {
+  class ErrorPrototypeImp : public ObjectImp {
   public:
-    ErrorObject(const Object &funcProto, const Object &errProto,
-                ErrorType t = GeneralError);
-    ErrorObject(const Object& proto, ErrorType t, const char *m, int l = -1);
-    Completion execute(const List &);
-    Object construct(const List &);
-    static Object create(ErrorType e, const char *m, int ln);
+    ErrorPrototypeImp(ExecState *exec,
+                      ObjectPrototypeImp *objectProto,
+                      FunctionPrototypeImp *funcProto);
+  };
+
+  class ErrorProtoFuncImp : public InternalFunctionImp {
+  public:
+    ErrorProtoFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+  };
+
+  class ErrorObjectImp : public InternalFunctionImp {
+  public:
+    ErrorObjectImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                   ErrorPrototypeImp *errorProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+  };
+
+
+
+
+
+  class NativeErrorPrototypeImp : public ObjectImp {
+  public:
+    NativeErrorPrototypeImp(ExecState *exec, ErrorPrototypeImp *errorProto,
+                            ErrorType et, UString name, UString message);
   private:
     ErrorType errType;
-    static const char *errName[];
   };
 
-  class ErrorPrototype : public ObjectImp {
+  class NativeErrorImp : public InternalFunctionImp {
   public:
-    ErrorPrototype(const Object& proto);
-    virtual KJSO get(const UString &p) const;
-  };
+    NativeErrorImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                   const Object &prot);
 
-  class ErrorProtoFunc : public InternalFunctionImp {
-  public:
-    ErrorProtoFunc() { }
-    Completion execute(const List &);
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    virtual void mark();
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  private:
+    ObjectImp *proto;
   };
 

trunk/JavaScriptCore/kjs/function.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
  */
 
 #include "function.h"
 
-#include "kjs.h"
-#include "types.h"
 #include "internal.h"
+#include "function_object.h"
+#include "lexer.h"
+#include "nodes.h"
 #include "operations.h"
-#include "nodes.h"
-#ifndef NDEBUG
+#include "debugger.h"
+
 #include <stdio.h>
-#endif
+#include <assert.h>
+#include <string.h>
 
 using namespace KJS;
 
-const TypeInfo FunctionImp::info = { "Function", FunctionType,
-                                      &ObjectImp::info, 0, 0 };
-const TypeInfo InternalFunctionImp::info = { "InternalFunction",
-                                              InternalFunctionType,
-                                              &FunctionImp::info, 0, 0 };
-const TypeInfo ConstructorImp::info = { "Function", ConstructorType,
-                                         &InternalFunctionImp::info, 0, 0 };
+// ------------------------------ FunctionImp ----------------------------------
+
+const ClassInfo FunctionImp::info = {"Function", &InternalFunctionImp::info, 0, 0};
 
 namespace KJS {
-
   class Parameter {
   public:
@@ -49 +49 @@
     Parameter *next;
   };
-
 };
 
-FunctionImp::FunctionImp()
-  : ObjectImp(/*TODO*/BooleanClass), param(0L)
-{
-}
-
-FunctionImp::FunctionImp(const UString &n)
-  : ObjectImp(/*TODO*/BooleanClass), ident(n), param(0L)
-{
+FunctionImp::FunctionImp(ExecState *exec, const UString &n)
+  : InternalFunctionImp(
+      static_cast<FunctionPrototypeImp*>(exec->interpreter()->builtinFunctionPrototype().imp())
+      ), param(0L), ident(n), argStack(0)
+{
+  Value protect(this);
+  argStack = new ListImp();
+  put(exec,"arguments",Null(),ReadOnly|DontDelete|DontEnum);
 }
 
 FunctionImp::~FunctionImp()
 {
+  argStack->setGcAllowed();
+  // The function shouldn't be deleted while it is still executed; argStack
+  // should be set to 0 by the last call to popArgs()
+  assert(argStack->isEmpty());
   delete param;
 }
 
-KJSO FunctionImp::thisValue() const
-{
-  return KJSO(Context::current()->thisValue());
+void FunctionImp::mark()
+{
+  InternalFunctionImp::mark();
+  if (argStack && !argStack->marked())
+    argStack->mark();
+}
+
+bool FunctionImp::implementsCall() const
+{
+  return true;
+}
+
+Value FunctionImp::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  Object globalObj = exec->interpreter()->globalObject();
+
+  Debugger *dbg = exec->interpreter()->imp()->debugger();
+  int sid = -1;
+  int lineno = -1;
+  if (dbg) {
+    if (inherits(&DeclaredFunctionImp::info)) {
+      sid = static_cast<DeclaredFunctionImp*>(this)->body->sourceId();
+      lineno = static_cast<DeclaredFunctionImp*>(this)->body->firstLine();
+    }
+
+    Object func(this);
+    int cont = dbg->callEvent(exec,sid,lineno,func,args);
+    if (!cont) {
+      dbg->imp()->abort();
+      return Undefined();
+    }
+  }
+
+  // enter a new execution context
+  ContextImp *ctx = new ContextImp(globalObj, exec, thisObj,
+                                   codeType(), exec->context().imp(), this, args);
+  ExecState *newExec = new ExecState(exec->interpreter(),ctx);
+  newExec->setException(exec->exception()); // could be null
+
+  // In order to maintain our "arguments" property, we maintain a list of arguments
+  // properties from earlier in the execution stack. Upon return, we restore the
+  // previous arguments object using popArgs().
+  // Note: this does not appear to be part of the spec
+  if (codeType() == FunctionCode) {
+    assert(ctx->activationObject().inherits(&ActivationImp::info));
+    Object argsObj = static_cast<ActivationImp*>(ctx->activationObject().imp())->argumentsObject();
+    put(newExec,"arguments", argsObj, DontDelete|DontEnum|ReadOnly);
+    pushArgs(newExec,argsObj);
+  }
+
+  // assign user supplied arguments to parameters
+  processParameters(newExec,args);
+  // add variable declarations (initialized to undefined)
+  processVarDecls(newExec);
+
+  Completion comp = execute(newExec);
+
+  // if an exception occured, propogate it back to the previous execution object
+  if (newExec->hadException())
+    exec->setException(newExec->exception());
+  if (codeType() == FunctionCode)
+    popArgs(newExec);
+  delete newExec;
+  delete ctx;
+
+#ifdef KJS_VERBOSE
+  if (comp.complType() == Throw)
+    printInfo(exec,"throwing", comp.value());
+  else if (comp.complType() == ReturnValue)
+    printInfo(exec,"returning", comp.value());
+  else
+    fprintf(stderr, "returning: undefined\n");
+#endif
+
+  if (dbg) {
+    Object func(this);
+    int cont = dbg->returnEvent(exec,sid,lineno,func);
+    if (!cont) {
+      dbg->imp()->abort();
+      return Undefined();
+    }
+  }
+
+  if (comp.complType() == Throw) {
+    exec->setException(comp.value());
+    return comp.value();
+  }
+  else if (comp.complType() == ReturnValue)
+    return comp.value();
+  else
+    return Undefined();
 }
 
@@ -81 +172 @@
 }
 
-void FunctionImp::setLength(int l)
-{
-  put("length", Number(l), ReadOnly|DontDelete|DontEnum);
-}
-
-// ECMA 10.1.3
-void FunctionImp::processParameters(const List *args)
-{
-  KJSO variable = Context::current()->variableObject();
-
-  assert(args);
+
+// ECMA 10.1.3q
+void FunctionImp::processParameters(ExecState *exec, const List &args)
+{
+  Object variable = exec->context().imp()->variableObject();
 
 #ifdef KJS_VERBOSE
@@ -100 +185 @@
 
   if (param) {
-    ListIterator it = args->begin();
+    ListIterator it = args.begin();
     Parameter **p = &param;
     while (*p) {
-      if (it != args->end()) {
+      if (it != args.end()) {
 #ifdef KJS_VERBOSE
         fprintf(stderr, "setting parameter %s ", (*p)->name.ascii());
-        printInfo("to", *it);
+        printInfo(exec,"to", *it);
 #endif
-        variable.put((*p)->name, *it);
+        variable.put(exec,(*p)->name, *it);
         it++;
       } else
-        variable.put((*p)->name, Undefined());
+        variable.put(exec,(*p)->name, Undefined());
       p = &(*p)->next;
     }
@@ -117 +202 @@
 #ifdef KJS_VERBOSE
   else {
-    for (int i = 0; i < args->size(); i++)
-      printInfo("setting argument", (*args)[i]);
+    for (int i = 0; i < args.size(); i++)
+      printInfo(exec,"setting argument", args[i]);
   }
 #endif
-#ifdef KJS_DEBUGGER
-  if (KJScriptImp::current()->debugger()) {
-    UString argStr;
-    for (int i = 0; i < args->size(); i++) {
-      if (i > 0)
-        argStr += ", ";
-      Imp *a = (*args)[i].imp();
-      argStr += a->toString().value() + " : " + UString(a->typeInfo()->name);
-    }
-    UString n = name().isEmpty() ? UString( "(internal)" ) : name();
-    KJScriptImp::current()->debugger()->callEvent(n, argStr);
-  }
-#endif
-}
-
-// ECMA 13.2.1
-KJSO FunctionImp::executeCall(Imp *thisV, const List *args)
-{
-  return executeCall(thisV,args,0);
-}
-
-KJSO FunctionImp::executeCall(Imp *thisV, const List *args, const List *extraScope)
-{
-  bool dummyList = false;
-  if (!args) {
-    args = new List();
-    dummyList = true;
-  }
-
-  KJScriptImp *curr = KJScriptImp::current();
-  Context *save = curr->context();
-
-  Context *ctx = new Context(codeType(), save, this, args, thisV);
-  curr->setContext(ctx);
-
-  int numScopes = 0;
-  if (extraScope) {
-    ListIterator scopeIt = extraScope->begin();
-    for (; scopeIt != extraScope->end(); scopeIt++) {
-      KJSO obj(*scopeIt);
-      ctx->pushScope(obj);
-      numScopes++;
-    }
-  }
-
-  // assign user supplied arguments to parameters
-  processParameters(args);
-
-  Completion comp = execute(*args);
-
-  if (dummyList)
-    delete args;
-
-  int i;
-  for (i = 0; i < numScopes; i++)
-    ctx->popScope();
-
-  put("arguments", Null());
-  delete ctx;
-  curr->setContext(save);
-
-#ifdef KJS_VERBOSE
-  if (comp.complType() == Throw)
-    printInfo("throwing", comp.value());
-  else if (comp.complType() == ReturnValue)
-    printInfo("returning", comp.value());
+}
+
+void FunctionImp::processVarDecls(ExecState */*exec*/)
+{
+}
+
+void FunctionImp::pushArgs(ExecState *exec, const Object &args)
+{
+  argStack->append(args);
+  put(exec,"arguments",args,ReadOnly|DontDelete|DontEnum);
+}
+
+void FunctionImp::popArgs(ExecState *exec)
+{
+  argStack->removeLast();
+  if (argStack->isEmpty()) {
+    put(exec,"arguments",Null(),ReadOnly|DontDelete|DontEnum);
+  }
   else
-    fprintf(stderr, "returning: undefined\n");
-#endif
-#ifdef KJS_DEBUGGER
-  if (KJScriptImp::current()->debugger())
-    KJScriptImp::current()->debugger()->returnEvent();
-#endif
-
-  if (comp.complType() == Throw)
-    return comp.value();
-  else if (comp.complType() == ReturnValue)
-    return comp.value();
+    put(exec,"arguments",argStack->at(argStack->size()-1),ReadOnly|DontDelete|DontEnum);
+}
+
+// ------------------------------ DeclaredFunctionImp --------------------------
+
+// ### is "Function" correct here?
+const ClassInfo DeclaredFunctionImp::info = {"Function", &FunctionImp::info, 0, 0};
+
+DeclaredFunctionImp::DeclaredFunctionImp(ExecState *exec, const UString &n,
+                                         FunctionBodyNode *b, const List &sc)
+  : FunctionImp(exec,n), body(b)
+{
+  Value protect(this);
+  body->ref();
+  setScope(sc.copy());
+}
+
+DeclaredFunctionImp::~DeclaredFunctionImp()
+{
+  if ( body->deref() )
+    delete body;
+}
+
+bool DeclaredFunctionImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 13.2.2 [[Construct]]
+Object DeclaredFunctionImp::construct(ExecState *exec, const List &args)
+{
+  Object proto;
+  Value p = get(exec,"prototype");
+  if (p.type() == ObjectType)
+    proto = Object(static_cast<ObjectImp*>(p.imp()));
   else
-    return Undefined();
-}
-
-UString FunctionImp::name() const
-{
-  return ident;
-}
-
-InternalFunctionImp::InternalFunctionImp()
-{
-}
-
-InternalFunctionImp::InternalFunctionImp(int l)
-{
-  if (l >= 0)
-    setLength(l);
-}
-
-InternalFunctionImp::InternalFunctionImp(const UString &n)
-  : FunctionImp(n)
-{
-}
-
-String InternalFunctionImp::toString() const
-{
-  if (name().isNull())
-    return UString("(Internal function)");
+    proto = exec->interpreter()->builtinObjectPrototype();
+
+  Object obj(new ObjectImp(proto));
+
+  Value res = call(exec,obj,args);
+
+  if (res.type() == ObjectType)
+    return Object::dynamicCast(res);
   else
-    return UString("function " + name() + "()");
-}
-
-Completion InternalFunctionImp::execute(const List &)
-{
-  return Completion(ReturnValue, Undefined());
-}
-
-ConstructorImp::ConstructorImp() {
-  setPrototype(Global::current().functionPrototype());
-  // TODO ???  put("constructor", this);
-  setLength(1);
-}
-
-ConstructorImp::ConstructorImp(const UString &n)
-  : InternalFunctionImp(n)
-{
-}
-
-ConstructorImp::ConstructorImp(const KJSO &p, int len)
-{
-  setPrototype(p);
-  // TODO ???  put("constructor", *this);
-  setLength(len);
-}
-
-ConstructorImp::ConstructorImp(const UString &n, const KJSO &p, int len)
-  : InternalFunctionImp(n)
-{
-  setPrototype(p);
-  // TODO ???  put("constructor", *this);
-  setLength(len);
-}
-
-ConstructorImp::~ConstructorImp() { }
-
-Completion ConstructorImp::execute(const List &)
-{
-  /* TODO */
-  return Completion(ReturnValue, Null());
-}
-
-Function::Function(Imp *d)
-  : KJSO(d)
-{
-  if (d) {
-    static_cast<FunctionImp*>(rep)->attr = ImplicitNone;
-    assert(Global::current().hasProperty("[[Function.prototype]]"));
-    setPrototype(Global::current().functionPrototype());
-  }
-}
-
-Completion Function::execute(const List &args)
-{
-  assert(rep);
-  return static_cast<FunctionImp*>(rep)->execute(args);
-}
-
-bool Function::hasAttribute(FunctionAttribute a) const
-{
-  assert(rep);
-  return static_cast<FunctionImp*>(rep)->hasAttribute(a);
-}
-
-#if 0
-InternalFunction::InternalFunction(Imp *d)
-  : Function(d)
-{
-  param = 0L;
-}
-
-InternalFunction::~InternalFunction()
-{
-}
-#endif
-
-Constructor::Constructor(Imp *d)
-  : Function(d)
-{
-  if (d) {
-    assert(Global::current().hasProperty("[[Function.prototype]]"));
-    setPrototype(Global::current().get("[[Function.prototype]]"));
-    put("constructor", *this);
-    KJSO tmp(d); // protect from GC
-    ((FunctionImp*)d)->setLength(1);
-  }
-}
-
-#if 0
-Constructor::Constructor(const Object& proto, int len)
-{
-  setPrototype(proto);
-  put("constructor", *this);
-  put("length", len, DontEnum);
-}
-#endif
-
-Constructor::~Constructor()
-{
-}
-
-Completion Constructor::execute(const List &)
-{
-  /* TODO: call construct instead ? */
-  return Completion(ReturnValue, Undefined());
-}
-
-Object Constructor::construct(const List &args)
-{
-  assert(rep && rep->type() == ConstructorType);
-  return ((ConstructorImp*)rep)->construct(args);
-}
-
-Constructor Constructor::dynamicCast(const KJSO &obj)
-{
-  // return null object on type mismatch
-  if (!obj.isA(ConstructorType))
-    return Constructor(0L);
-
-  return Constructor(obj.imp());
-}
-
-KJSO Function::thisValue() const
-{
-  return KJSO(Context::current()->thisValue());
-}
+    return obj;
+}
+
+Completion DeclaredFunctionImp::execute(ExecState *exec)
+{
+  Completion result = body->execute(exec);
+
+  if (result.complType() == Throw || result.complType() == ReturnValue)
+      return result;
+  return Completion(Normal, Undefined()); // TODO: or ReturnValue ?
+}
+
+void DeclaredFunctionImp::processVarDecls(ExecState *exec)
+{
+  body->processVarDecls(exec);
+}
+
+// ------------------------------ ArgumentsImp ---------------------------------
+
+const ClassInfo ArgumentsImp::info = {"Arguments", 0, 0, 0};
+
+// ECMA 10.1.8
+ArgumentsImp::ArgumentsImp(ExecState *exec, FunctionImp *func, const List &args)
+  : ObjectImp(exec->interpreter()->builtinObjectPrototype())
+{
+  Value protect(this);
+  put(exec,"callee", Object(func), DontEnum);
+  put(exec,"length", Number(args.size()), DontEnum);
+  if (!args.isEmpty()) {
+    ListIterator arg = args.begin();
+    for (int i = 0; arg != args.end(); arg++, i++) {
+      put(exec,UString::from(i), *arg, DontEnum);
+    }
+  }
+}
+
+// ------------------------------ ActivationImp --------------------------------
+
+const ClassInfo ActivationImp::info = {"Activation", 0, 0, 0};
+
+// ECMA 10.1.6
+ActivationImp::ActivationImp(ExecState *exec, FunctionImp *f, const List &args)
+  : ObjectImp()
+{
+  Value protect(this);
+  arguments = new ArgumentsImp(exec,f, args);
+  put(exec, "arguments", Object(arguments), Internal|DontDelete);
+}
+
+ActivationImp::~ActivationImp()
+{
+  arguments->setGcAllowed();
+}
+
+// ------------------------------ GlobalFunc -----------------------------------
+
+
+GlobalFuncImp::GlobalFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto, int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+CodeType GlobalFuncImp::codeType() const
+{
+  return id == Eval ? EvalCode : codeType();
+}
+
+bool GlobalFuncImp::implementsCall() const
+{
+  return true;
+}
+
+Value GlobalFuncImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  Value res;
+
+  static const char non_escape[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                   "abcdefghijklmnopqrstuvwxyz"
+                                   "0123456789@*_+-./";
+
+  if (id == Eval) { // eval()
+    Value x = args[0];
+    if (x.type() != StringType)
+      return x;
+    else {
+      UString s = x.toString(exec);
+
+      int sid;
+      int errLine;
+      UString errMsg;
+      ProgramNode *progNode = Parser::parse(s.data(),s.size(),&sid,&errLine,&errMsg);
+
+      // no program node means a syntax occurred
+      if (!progNode) {
+        Object err = Error::create(exec,SyntaxError,errMsg.ascii(),errLine);
+        err.put(exec,"sid",Number(sid));
+        exec->setException(err);
+        return err;
+      }
+
+      progNode->ref();
+
+      // enter a new execution context
+      Object glob(exec->interpreter()->globalObject());
+      Object thisVal(Object::dynamicCast(exec->context().thisValue()));
+      ContextImp *ctx = new ContextImp(glob,
+                                       exec,
+                                       thisVal,
+                                       EvalCode,
+                                       exec->context().imp());
+
+      ExecState *newExec = new ExecState(exec->interpreter(),ctx);
+      newExec->setException(exec->exception()); // could be null
+
+      // execute the code
+      Completion c = progNode->execute(newExec);
+
+      // if an exception occured, propogate it back to the previous execution object
+      if (newExec->hadException())
+        exec->setException(newExec->exception());
+      delete newExec;
+      delete ctx;
+
+      if ( progNode->deref() )
+          delete progNode;
+      if (c.complType() == ReturnValue)
+          return c;
+      // ### setException() on throw?
+      else if (c.complType() == Normal) {
+          if (c.isValueCompletion())
+              return c.value();
+          else
+              return Undefined();
+      } else
+          return c;
+    }
+  } else if (id == ParseInt) {
+    String str = args[0].toString(exec);
+    int radix = args[1].toInt32(exec);
+    if (radix == 0)
+      radix = 10;
+    else if (radix < 2 || radix > 36) {
+      res = Number(NaN);
+      return res;
+    }
+    /* TODO: use radix */
+    // Can't use toULong(), we want to accept floating point values too
+    double value = str.value().toDouble( true /*tolerant*/ );
+    if ( isNaN(value) )
+        res = Number(NaN);
+    else
+        res = Number(static_cast<long>(value)); // remove floating-point part
+  } else if (id == ParseFloat) {
+    String str = args[0].toString(exec);
+    res = Number(str.value().toDouble( true /*tolerant*/ ));
+  } else if (id == IsNaN) {
+    res = Boolean(isNaN(args[0].toNumber(exec)));
+  } else if (id == IsFinite) {
+    Number n = args[0].toNumber(exec);
+    res = Boolean(!n.isNaN() && !n.isInf());
+  } else if (id == Escape) {
+    UString r = "", s, str = args[0].toString(exec);
+    const UChar *c = str.data();
+    for (int k = 0; k < str.size(); k++, c++) {
+      int u = c->unicode();
+      if (u > 255) {
+        char tmp[7];
+        sprintf(tmp, "%%u%04X", u);
+        s = UString(tmp);
+      } else if (strchr(non_escape, (char)u)) {
+        s = UString(c, 1);
+      } else {
+        char tmp[4];
+        sprintf(tmp, "%%%02X", u);
+        s = UString(tmp);
+      }
+      r += s;
+    }
+    res = String(r);
+  } else if (id == UnEscape) {
+    UString s, str = args[0].toString(exec);
+    int k = 0, len = str.size();
+    while (k < len) {
+      const UChar *c = str.data() + k;
+      UChar u;
+      if (*c == UChar('%') && k <= len - 6 && *(c+1) == UChar('u')) {
+        u = Lexer::convertUnicode((c+2)->unicode(), (c+3)->unicode(),
+                                  (c+4)->unicode(), (c+5)->unicode());
+        c = &u;
+        k += 5;
+      } else if (*c == UChar('%') && k <= len - 3) {
+        u = UChar(Lexer::convertHex((c+1)->unicode(), (c+2)->unicode()));
+        c = &u;
+        k += 2;
+      }
+      k++;
+      s += UString(c, 1);
+    }
+    res = String(s);
+  }
+
+  return res;
+}

trunk/JavaScriptCore/kjs/function.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
@@ -22 +25 @@
 #define _KJS_FUNCTION_H_
 
-#include <assert.h>
-
-#include "object.h"
-#include "types.h"
+#include "internal.h"
 
 namespace KJS {
 
-  enum CodeType { GlobalCode,
-                  EvalCode,
-                  FunctionCode,
-                  AnonymousCode,
-                  HostCode };
-
-  enum FunctionAttribute { ImplicitNone, ImplicitThis, ImplicitParents };
-
-  class Function;
   class Parameter;
 
   /**
-   * @short Implementation class for Functions.
+   * @short Implementation class for internal Functions.
    */
-  class FunctionImp : public ObjectImp {
+  class FunctionImp : public InternalFunctionImp {
     friend class Function;
+    friend class ActivationImp;
   public:
-    FunctionImp();
-    FunctionImp(const UString &n);
+    FunctionImp(ExecState *exec, const UString &n = UString::null);
     virtual ~FunctionImp();
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-    virtual Completion execute(const List &) = 0;
-    bool hasAttribute(FunctionAttribute a) const { return (attr & a) != 0; }
+
+    virtual void mark();
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    void addParameter(const UString &n);
     virtual CodeType codeType() const = 0;
-    KJSO thisValue() const;
-    void addParameter(const UString &n);
-    void setLength(int l);
-    KJSO executeCall(Imp *thisV, const List *args);
-    KJSO executeCall(Imp *thisV, const List *args, const List *extraScope);
-    UString name() const;
+
+    virtual Completion execute(ExecState *exec) = 0;
+    UString name() const { return ident; }
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   protected:
+    Parameter *param;
     UString ident;
-    FunctionAttribute attr;
-    Parameter *param;
+
   private:
-    void processParameters(const List *);
+    void processParameters(ExecState *exec, const List &);
+    virtual void processVarDecls(ExecState *exec);
+
+    void pushArgs(ExecState *exec, const Object &args);
+    void popArgs(ExecState *exec);
+    ListImp *argStack;
   };
 
-  /**
-   * @short Abstract base class for internal functions.
-   */
-  class InternalFunctionImp : public FunctionImp {
+  class DeclaredFunctionImp : public FunctionImp {
   public:
-    InternalFunctionImp();
-    InternalFunctionImp(int l);
-    InternalFunctionImp(const UString &n);
-    virtual ~InternalFunctionImp() { }
-    virtual String toString() const;
-    virtual KJSO toPrimitive(Type) const { return toString(); }
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-    virtual Completion execute(const List &);
-    virtual CodeType codeType() const { return HostCode; }
+    DeclaredFunctionImp(ExecState *exec, const UString &n,
+                        FunctionBodyNode *b, const List &sc);
+    ~DeclaredFunctionImp();
+
+    bool implementsConstruct() const;
+    Object construct(ExecState *exec, const List &args);
+
+    virtual Completion execute(ExecState *exec);
+    CodeType codeType() const { return FunctionCode; }
+    FunctionBodyNode *body;
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  private:
+    virtual void processVarDecls(ExecState *exec);
   };
 
-  /**
-   * @short Base class for Function objects.
-   */
-  class Function : public KJSO {
+
+
+
+  class ArgumentsImp : public ObjectImp {
   public:
-    Function(Imp *);
-    virtual ~Function() { }
-    Completion execute(const List &);
-    bool hasAttribute(FunctionAttribute a) const;
-    CodeType codeType() const { return HostCode; }
-    KJSO thisValue() const;
-  };
-  
-  /**
-   * @short Implementation class for Constructors.
-   */
-  class ConstructorImp : public InternalFunctionImp {
-  public:
-    ConstructorImp();
-    ConstructorImp(const UString &n);   /* TODO: add length */
-    ConstructorImp(const KJSO &, int);
-    ConstructorImp(const UString &n, const KJSO &p, int len);
-    virtual ~ConstructorImp();
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-    virtual Completion execute(const List &);
-    virtual Object construct(const List &) = 0;
+    ArgumentsImp(ExecState *exec, FunctionImp *func, const List &args);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   };
 
-  /**
-    * @short Constructor object for use with the 'new' operator
-    */
-  class Constructor : public Function {
+  class ActivationImp : public ObjectImp {
   public:
-    Constructor(Imp *);
-    virtual ~Constructor();
-    //    Constructor(const Object& proto, int len);
-    /**
-     * @return @ref ConstructorType
-     */
-    Completion execute(const List &);
-    Object construct(const List &args);
-    static Constructor dynamicCast(const KJSO &obj);
+    ActivationImp(ExecState *exec, FunctionImp *f, const List &args);
+    ~ActivationImp();
+
+    Object argumentsObject() { return Object(arguments); }
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  private:
+    ObjectImp* arguments;
   };
+
+  class GlobalFuncImp : public InternalFunctionImp {
+  public:
+    GlobalFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto, int i, int len);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+    virtual CodeType codeType() const;
+    enum { Eval, ParseInt, ParseFloat, IsNaN, IsFinite, Escape, UnEscape };
+  private:
+    int id;
+  };
+
+
 
 }; // namespace

trunk/JavaScriptCore/kjs/function_object.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 1999-2001 Harri Porten ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -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
+ *
  */
 
 #include "function_object.h"
-
+#include "internal.h"
+#include "function.h"
+#include "array_object.h"
+#include "nodes.h"
 #include "lexer.h"
-#include "nodes.h"
-#include "error_object.h"
-
-extern int kjsyyparse();
+#include "debugger.h"
+#include "object.h"
+
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
 
 using namespace KJS;
 
-FunctionObject::FunctionObject(const Object& funcProto)
-  : ConstructorImp(funcProto, 1)
-{
-  // ECMA 15.3.3.1 Function.prototype
-  setPrototypeProperty(funcProto);
-}
-
-// ECMA 15.3.1 The Function Constructor Called as a Function
-Completion FunctionObject::execute(const List &args)
-{
-  return Completion(ReturnValue, construct(args));
+// ------------------------------ FunctionPrototypeImp -------------------------
+
+FunctionPrototypeImp::FunctionPrototypeImp(ExecState *exec)
+  : InternalFunctionImp(0)
+{
+  Value protect(this);
+  put(exec, "toString", Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::ToString, 0)), DontEnum);
+  put(exec, "apply",    Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::Apply,    2)), DontEnum);
+  put(exec, "call",     Object(new FunctionProtoFuncImp(exec, this, FunctionProtoFuncImp::Call,     1)), DontEnum);
+}
+
+FunctionPrototypeImp::~FunctionPrototypeImp()
+{
+}
+
+bool FunctionPrototypeImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.3.4
+Value FunctionPrototypeImp::call(ExecState */*exec*/, Object &/*thisObj*/, const List &/*args*/)
+{
+  return Undefined();
+}
+
+// ------------------------------ FunctionProtoFuncImp -------------------------
+
+FunctionProtoFuncImp::FunctionProtoFuncImp(ExecState *exec,
+                                         FunctionPrototypeImp *funcProto, int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+
+bool FunctionProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+Value FunctionProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  Value result;
+
+  switch (id) {
+  case ToString: {
+    // ### also make this work for internal functions
+    // ### return the text of the function body (see 15.3.4.2)
+    if (thisObj.isNull() || !thisObj.inherits(&InternalFunctionImp::info)) {
+#ifndef NDEBUG
+      fprintf(stderr,"attempted toString() call on null or non-function object\n");
+#endif
+      Object err = Error::create(exec,TypeError);
+      exec->setException(err);
+      return err;
+    }
+    if (thisObj.inherits(&FunctionImp::info) &&
+        !static_cast<FunctionImp*>(thisObj.imp())->name().isNull()) {
+      result = String("function " + static_cast<FunctionImp*>(thisObj.imp())->name() + "()");
+    }
+    else {
+      result = String("(Internal function)");
+    }
+    }
+    break;
+  case Apply: {
+    Value thisArg = args[0];
+    Value argArray = args[1];
+    Object func = thisObj;
+
+    if (!func.implementsCall()) {
+      Object err = Error::create(exec,TypeError);
+      exec->setException(err);
+      return err;
+    }
+
+    Object applyThis;
+    if (thisArg.isA(NullType) || thisArg.isA(UndefinedType))
+      applyThis = exec->interpreter()->globalObject();
+    else
+      applyThis = thisArg.toObject(exec);
+
+    List applyArgs;
+    if (!argArray.isA(NullType) && !argArray.isA(UndefinedType)) {
+      if ((argArray.isA(ObjectType) &&
+           Object::dynamicCast(argArray).inherits(&ArrayInstanceImp::info)) ||
+           Object::dynamicCast(argArray).inherits(&ArgumentsImp::info)) {
+
+        Object argArrayObj = Object::dynamicCast(argArray);
+        unsigned int length = argArrayObj.get(exec,"length").toUInt32(exec);
+        for (uint i = 0; i < length; i++)
+          applyArgs.append(argArrayObj.get(exec,UString::from(i)));
+      }
+      else {
+        Object err = Error::create(exec,TypeError);
+        exec->setException(err);
+        return err;
+      }
+    }
+    result = func.call(exec,applyThis,applyArgs);
+    }
+    break;
+  case Call: {
+    Value thisArg = args[0];
+    Object func = thisObj;
+
+    if (!func.implementsCall()) {
+      Object err = Error::create(exec,TypeError);
+      exec->setException(err);
+      return err;
+    }
+
+    Object callThis;
+    if (thisArg.isA(NullType) || thisArg.isA(UndefinedType))
+      callThis = exec->interpreter()->globalObject();
+    else
+      callThis = thisArg.toObject(exec);
+
+    List callArgs = args.copy();
+    callArgs.removeFirst();
+    result = func.call(exec,callThis,callArgs);
+    }
+    break;
+  }
+
+  return result;
+}
+
+// ------------------------------ FunctionObjectImp ----------------------------
+
+FunctionObjectImp::FunctionObjectImp(ExecState *exec, FunctionPrototypeImp *funcProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
+  put(exec,"prototype", Object(funcProto), DontEnum|DontDelete|ReadOnly);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+}
+
+FunctionObjectImp::~FunctionObjectImp()
+{
+}
+
+bool FunctionObjectImp::implementsConstruct() const
+{
+  return true;
 }
 
 // ECMA 15.3.2 The Function Constructor
-Object FunctionObject::construct(const List &args)
+Object FunctionObjectImp::construct(ExecState *exec, const List &args)
 {
   UString p("");
@@ -50 +195 @@
     body = "";
   } else if (argsSize == 1) {
-    body = args[0].toString().value();
+    body = args[0].toString(exec);
   } else {
-    p = args[0].toString().value();
+    p = args[0].toString(exec);
     for (int k = 1; k < argsSize - 1; k++)
-      p += "," + args[k].toString().value();
-    body = args[argsSize-1].toString().value();
-  }
-
-  Lexer::curr()->setCode(body.data(), body.size());
-
-  KJScriptImp::current()->pushStack();
-  int yp = kjsyyparse();
-  ProgramNode *progNode = KJScriptImp::current()->progNode();
-  KJScriptImp::current()->popStack();
-  if (yp) {
-    /* TODO: free nodes */
-    return ErrorObject::create(SyntaxError,
-                               I18N_NOOP("Syntax error in function body"), -1);
+      p += "," + args[k].toString(exec);
+    body = args[argsSize-1].toString(exec);
+  }
+
+  // parse the source code
+  int sid;
+  int errLine;
+  UString errMsg;
+  ProgramNode *progNode = Parser::parse(body.data(),body.size(),&sid,&errLine,&errMsg);
+
+  // notify debugger that source has been parsed
+  Debugger *dbg = exec->interpreter()->imp()->debugger();
+  if (dbg) {
+    bool cont = dbg->sourceParsed(exec,sid,body,errLine);
+    if (!cont) {
+      dbg->imp()->abort();
+      return Object(new ObjectImp());
+    }
+  }
+
+  // no program node == syntax error - throw a syntax error
+  if (!progNode) {
+    Object err = Error::create(exec,SyntaxError,errMsg.ascii(),errLine);
+    // we can't return a Completion(Throw) here, so just set the exception
+    // and return it
+    exec->setException(err);
+    return err;
   }
 
   List scopeChain;
-  scopeChain.append(Global::current());
+  scopeChain.append(exec->interpreter()->globalObject());
   FunctionBodyNode *bodyNode = progNode;
-  FunctionImp *fimp = new DeclaredFunctionImp(UString::null, bodyNode,
-                                              &scopeChain);
+
+  FunctionImp *fimp = new DeclaredFunctionImp(exec, UString::null, bodyNode,
+                                              scopeChain);
   Object ret(fimp); // protect from GC
 
@@ -106 +265 @@
           } // else error
       }
-      return ErrorObject::create(SyntaxError,
+      Object err = Error::create(exec,SyntaxError,
                                  I18N_NOOP("Syntax error in parameter list"),
                                  -1);
-  }
-
-  fimp->setLength(params);
-  fimp->setPrototypeProperty(Global::current().functionPrototype());
+      exec->setException(err);
+      return err;
+  }
+
+  fimp->put(exec,"length", Number(params),ReadOnly|DontDelete|DontEnum);
+  List consArgs;
+
+  Object objCons = exec->interpreter()->builtinObject();
+  Object prototype = objCons.construct(exec,List::empty());
+  prototype.put(exec, "constructor",
+                Object(fimp), DontEnum|DontDelete|ReadOnly);
+  fimp->put(exec,"prototype",prototype,DontEnum|DontDelete|ReadOnly);
+  fimp->put(exec,"arguments",Null(),DontEnum|DontDelete|ReadOnly);
   return ret;
 }
 
-FunctionPrototype::FunctionPrototype(const Object &p)
-    : ObjectImp(FunctionClass, Null(), p)
-{
-}
+bool FunctionObjectImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.3.1 The Function Constructor Called as a Function
+Value FunctionObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  return construct(exec,args);
+}
+

trunk/JavaScriptCore/kjs/function_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _FUNCTION_OBJECT_H_
 
-#include "object.h"
+#include "internal.h"
+#include "object_object.h"
 #include "function.h"
 
 namespace KJS {
 
-  class FunctionPrototype : public ObjectImp {
+  /**
+   * @internal
+   *
+   * The initial value of Function.prototype (and thus all objects created
+   * with the Function constructor
+   */
+  class FunctionPrototypeImp : public InternalFunctionImp {
   public:
-    FunctionPrototype(const Object &p);
+    FunctionPrototypeImp(ExecState *exec);
+    virtual ~FunctionPrototypeImp();
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
   };
 
-  class FunctionObject : public ConstructorImp {
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * Function.prototype object
+   */
+  class FunctionProtoFuncImp : public InternalFunctionImp {
   public:
-    FunctionObject(const Object &funcProto);
-    Completion execute(const List &);
-    Object construct(const List &);
+    FunctionProtoFuncImp(ExecState *exec,
+                        FunctionPrototypeImp *funcProto, int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    enum { ToString, Apply, Call };
+  private:
+    int id;
+  };
+
+  /**
+   * @internal
+   *
+   * The initial value of the the global variable's "Function" property
+   */
+  class FunctionObjectImp : public InternalFunctionImp {
+  public:
+    FunctionObjectImp(ExecState *exec, FunctionPrototypeImp *funcProto);
+    virtual ~FunctionObjectImp();
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
   };
 
 }; // namespace
 
-#endif
+#endif // _FUNCTION_OBJECT_H_

trunk/JavaScriptCore/kjs/grammar.y

@@ -18 +18 @@
  *  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$
  */
 
@@ -24 +26 @@
 #endif
 #include <string.h>
-#include "kjs.h"
+#include <stdlib.h>
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "nodes.h"
 #include "lexer.h"
+#include "internal.h"
 
 /* default values for bison */
 #define YYDEBUG 0
 #define YYMAXDEPTH 0
-#ifdef KJS_DEBUGGER
+#ifdef APPLE_CHANGES
+#else
 #define YYERROR_VERBOSE
-#define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line); } // location
-#else
-#undef YYLSP_NEEDED
-#define DBG(l, s, e)
 #endif
+#define DBG(l, s, e) { l->setLoc(s.first_line, e.last_line, Parser::sid); } // location
 
 extern int yylex();
@@ -111 +116 @@
 
 /* automatically inserted semicolon */
-%token AUTO
+%token AUTOPLUSPLUS AUTOMINUSMINUS
 
 /* non-terminal types */
@@ -163 +168 @@
                                      if (!l->scanRegExp()) YYABORT;
                                      $$ = new RegExpNode(l->pattern,l->flags);}
+  | DIVEQUAL /* a RegExp starting with /= ! */
+                                   { Lexer *l = Lexer::curr();
+                                     if (!l->scanRegExp()) YYABORT;
+                                     $$ = new RegExpNode(UString('=')+l->pattern,l->flags);}
 ;
 
@@ -259 +268 @@
   | TYPEOF UnaryExpr               { $$ = new TypeOfNode($2); }
   | PLUSPLUS UnaryExpr             { $$ = new PrefixNode(OpPlusPlus, $2); }
-  | AUTO PLUSPLUS UnaryExpr        { $$ = new PrefixNode(OpPlusPlus, $3); }
+  | AUTOPLUSPLUS UnaryExpr         { $$ = new PrefixNode(OpPlusPlus, $2); }
   | MINUSMINUS UnaryExpr           { $$ = new PrefixNode(OpMinusMinus, $2); }
-  | AUTO MINUSMINUS UnaryExpr      { $$ = new PrefixNode(OpMinusMinus, $3); }
+  | AUTOMINUSMINUS UnaryExpr       { $$ = new PrefixNode(OpMinusMinus, $2); }
   | '+' UnaryExpr                  { $$ = new UnaryPlusNode($2); }
   | '-' UnaryExpr                  { $$ = new NegateNode($2); }
@@ -390 +399 @@
 Block:
     '{' '}'                        { $$ = new BlockNode(0L); DBG($$, @2, @2); }
-  | '{' StatementList '}'          { $$ = new BlockNode($2); DBG($$, @3, @3); }
+  | '{' SourceElements '}'          { $$ = new BlockNode($2); DBG($$, @3, @3); }
 ;
 
@@ -597 +606 @@
 
 FunctionBody:
-    '{' '}'  /* TODO: spec ??? */  { $$ = new FunctionBodyNode(0L); }
-  | '{' SourceElements '}'         { $$ = new FunctionBodyNode($2); }
+    '{' '}'  /* TODO: spec ??? */  { $$ = new FunctionBodyNode(0L);
+                                     DBG($$, @1, @2);}
+  | '{' SourceElements '}'         { $$ = new FunctionBodyNode($2);
+                                     DBG($$, @1, @3);}
 ;
 
 Program:
-    SourceElements                 { $$ = new ProgramNode($1);
-                                     KJScriptImp::current()->setProgNode($$); }
+    /* nothing, empty script */      { $$ = new ProgramNode(0L);
+                                     Parser::progNode = $$; }
+    | SourceElements                 { $$ = new ProgramNode($1);
+                                     Parser::progNode = $$; }
 ;
 

trunk/JavaScriptCore/kjs/internal.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
  */
 
+#include <stdio.h>
+#include <math.h>
+#include <assert.h>
+#ifndef NDEBUG
+#include <strings.h>      // for strdup
+#endif
+
+#include "array_object.h"
+#include "bool_object.h"
+#include "collector.h"
+#include "date_object.h"
+#include "debugger.h"
+#include "error_object.h"
+#include "function_object.h"
 #include "internal.h"
-
-#include <assert.h>
-#include <stdio.h>
-
-#include "kjs.h"
+#include "lexer.h"
+#include "math_object.h"
+#include "nodes.h"
+#include "number_object.h"
 #include "object.h"
-#include "types.h"
+#include "object_object.h"
 #include "operations.h"
-#include "regexp.h"
-#include "nodes.h"
-#include "lexer.h"
-#include "collector.h"
-#include "debugger.h"
+#include "regexp_object.h"
+#include "string_object.h"
 
 #define I18N_NOOP(s) s
@@ -40 +53 @@
 using namespace KJS;
 
-const TypeInfo UndefinedImp::info = { "Undefined", UndefinedType, 0, 0, 0 };
-const TypeInfo NullImp::info = { "Null", NullType, 0, 0, 0 };
-const TypeInfo NumberImp::info = { "Number", NumberType, 0, 0,0  };
-const TypeInfo StringImp::info = { "String", StringType, 0, 0, 0 };
-const TypeInfo BooleanImp::info = { "Boolean", BooleanType, 0, 0, 0 };
-const TypeInfo CompletionImp::info = { "Completion", CompletionType, 0, 0, 0 };
-const TypeInfo ReferenceImp::info = { "Reference", ReferenceType, 0, 0, 0 };
+namespace KJS {
+#ifdef WORDS_BIGENDIAN
+  unsigned char NaN_Bytes[] = { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 };
+  unsigned char Inf_Bytes[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 };
+#elif defined(arm)
+  unsigned char NaN_Bytes[] = { 0, 0, 0xf8, 0x7f, 0, 0, 0, 0 };
+  unsigned char Inf_Bytes[] = { 0, 0, 0xf0, 0x7f, 0, 0, 0, 0 };
+#else
+  unsigned char NaN_Bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f };
+  unsigned char Inf_Bytes[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
+#endif
+
+  const double NaN = *(const double*) NaN_Bytes;
+  const double Inf = *(const double*) Inf_Bytes;
+};
+
+// ------------------------------ UndefinedImp ---------------------------------
 
 UndefinedImp *UndefinedImp::staticUndefined = 0;
 
-UndefinedImp::UndefinedImp()
-{
-}
-
-KJSO UndefinedImp::toPrimitive(Type) const
-{
-  return (Imp*)this;
-}
-
-Boolean UndefinedImp::toBoolean() const
-{
-  return Boolean(false);
-}
-
-Number UndefinedImp::toNumber() const
-{
-  return Number(NaN);
-}
-
-String UndefinedImp::toString() const
-{
-  return String("undefined");
-}
-
-Object UndefinedImp::toObject() const
-{
-  return Error::createObject(TypeError, I18N_NOOP("Undefined value"));
-}
+Value UndefinedImp::toPrimitive(ExecState */*exec*/, Type) const
+{
+  return Value((ValueImp*)this);
+}
+
+bool UndefinedImp::toBoolean(ExecState */*exec*/) const
+{
+  return false;
+}
+
+double UndefinedImp::toNumber(ExecState */*exec*/) const
+{
+  return NaN;
+}
+
+UString UndefinedImp::toString(ExecState */*exec*/) const
+{
+  return "undefined";
+}
+
+Object UndefinedImp::toObject(ExecState *exec) const
+{
+  Object err = Error::create(exec, TypeError, I18N_NOOP("Undefined value"));
+  exec->setException(err);
+  return err;
+}
+
+// ------------------------------ NullImp --------------------------------------
 
 NullImp *NullImp::staticNull = 0;
 
-NullImp::NullImp()
-{
-}
-
-KJSO NullImp::toPrimitive(Type) const
-{
-  return (Imp*)this;
-}
-
-Boolean NullImp::toBoolean() const
-{
-  return Boolean(false);
-}
-
-Number NullImp::toNumber() const
-{
-  return Number(0);
-}
-
-String NullImp::toString() const
-{
-  return String("null");
-}
-
-Object NullImp::toObject() const
-{
-  return Error::createObject(TypeError, I18N_NOOP("Null value"));
-}
+Value NullImp::toPrimitive(ExecState */*exec*/, Type) const
+{
+  return Value((ValueImp*)this);
+}
+
+bool NullImp::toBoolean(ExecState */*exec*/) const
+{
+  return false;
+}
+
+double NullImp::toNumber(ExecState */*exec*/) const
+{
+  return 0.0;
+}
+
+UString NullImp::toString(ExecState */*exec*/) const
+{
+  return "null";
+}
+
+Object NullImp::toObject(ExecState *exec) const
+{
+  Object err = Error::create(exec, TypeError, I18N_NOOP("Null value"));
+  exec->setException(err);
+  return err;
+}
+
+// ------------------------------ BooleanImp -----------------------------------
 
 BooleanImp* BooleanImp::staticTrue = 0;
 BooleanImp* BooleanImp::staticFalse = 0;
 
-KJSO BooleanImp::toPrimitive(Type) const
-{
-  return (Imp*)this;
-}
-
-Boolean BooleanImp::toBoolean() const
-{
-  return Boolean((BooleanImp*)this);
-}
-
-Number BooleanImp::toNumber() const
-{
-  return Number(val ? 1 : 0);
-}
-
-String BooleanImp::toString() const
-{
-  return String(val ? "true" : "false");
-}
-
-Object BooleanImp::toObject() const
-{
-  return Object::create(BooleanClass, Boolean((BooleanImp*)this));
-}
+Value BooleanImp::toPrimitive(ExecState */*exec*/, Type) const
+{
+  return Value((ValueImp*)this);
+}
+
+bool BooleanImp::toBoolean(ExecState */*exec*/) const
+{
+  return val;
+}
+
+double BooleanImp::toNumber(ExecState */*exec*/) const
+{
+  return val ? 1.0 : 0.0;
+}
+
+UString BooleanImp::toString(ExecState */*exec*/) const
+{
+  return val ? "true" : "false";
+}
+
+Object BooleanImp::toObject(ExecState *exec) const
+{
+  List args;
+  args.append(Boolean(const_cast<BooleanImp*>(this)));
+  return Object::dynamicCast(exec->interpreter()->builtinBoolean().construct(exec,args));
+}
+
+// ------------------------------ StringImp ------------------------------------
+
+StringImp::StringImp(const UString& v)
+  : val(v)
+{
+}
+
+Value StringImp::toPrimitive(ExecState */*exec*/, Type) const
+{
+  return Value((ValueImp*)this);
+}
+
+bool StringImp::toBoolean(ExecState */*exec*/) const
+{
+  return (val.size() > 0);
+}
+
+double StringImp::toNumber(ExecState */*exec*/) const
+{
+  return val.toDouble();
+}
+
+UString StringImp::toString(ExecState */*exec*/) const
+{
+  return val;
+}
+
+Object StringImp::toObject(ExecState *exec) const
+{
+  List args;
+  args.append(String(const_cast<StringImp*>(this)));
+  return Object::dynamicCast(exec->interpreter()->builtinString().construct(exec,args));
+}
+
+// ------------------------------ NumberImp ------------------------------------
 
 NumberImp::NumberImp(double v)
@@ -143 +204 @@
 }
 
-KJSO NumberImp::toPrimitive(Type) const
-{
-  return (Imp*)this;
-}
-
-Boolean NumberImp::toBoolean() const
-{
-  bool b = !((val == 0) /* || (iVal() == N0) */ || isNaN(val));
-
-  return Boolean(b);
-}
-
-Number NumberImp::toNumber() const
+Value NumberImp::toPrimitive(ExecState *, Type) const
 {
   return Number((NumberImp*)this);
 }
 
-String NumberImp::toString() const
-{
-  return String(UString::from(val));
-}
-
-Object NumberImp::toObject() const
-{
-  return Object::create(NumberClass, Number((NumberImp*)this));
-}
-
-StringImp::StringImp(const UString& v)
-  : val(v)
-{
-}
-
-KJSO StringImp::toPrimitive(Type) const
-{
-  return (Imp*)this;
-}
-
-Boolean StringImp::toBoolean() const
-{
-  return Boolean(val.size() > 0);
-}
-
-Number StringImp::toNumber() const
-{
-  return Number(val.toDouble());
-}
-
-String StringImp::toString() const
-{
-  return String((StringImp*)this);
-}
-
-Object StringImp::toObject() const
-{
-  return Object::create(StringClass, String((StringImp*)this));
-}
-
-ReferenceImp::ReferenceImp(const KJSO& b, const UString& p)
-  : base(b), prop(p)
-{
-}
-
-void ReferenceImp::mark(Imp*)
-{
-  Imp::mark();
-  Imp *im = base.imp();
-  if (im && !im->marked())
-    im->mark();
-}
-
-CompletionImp::CompletionImp(Compl c, const KJSO& v, const UString& t)
-  : comp(c), val(v), tar(t)
-{
-}
-
-void CompletionImp::mark(Imp*)
-{
-  Imp::mark();
-  Imp *im = val.imp();
-  if (im && !im->marked())
-    im->mark();
-}
-
-RegExpImp::RegExpImp()
-  : ObjectImp(RegExpClass), reg(0L)
-{
-}
-
-RegExpImp::~RegExpImp()
-{
-  delete reg;
-}
+bool NumberImp::toBoolean(ExecState *) const
+{
+  return !((val == 0) /* || (iVal() == N0) */ || isNaN(val));
+}
+
+double NumberImp::toNumber(ExecState *) const
+{
+  return val;
+}
+
+UString NumberImp::toString(ExecState *) const
+{
+  return UString::from(val);
+}
+
+Object NumberImp::toObject(ExecState *exec) const
+{
+  List args;
+  args.append(Number(const_cast<NumberImp*>(this)));
+  return Object::dynamicCast(exec->interpreter()->builtinNumber().construct(exec,args));
+}
+
+// ------------------------------ ReferenceImp ---------------------------------
+
+ReferenceImp::ReferenceImp(const Value& v, const UString& p)
+  : base(v.imp()), prop(p)
+{
+}
+
+void ReferenceImp::mark()
+{
+  ValueImp::mark();
+  if (base && !base->marked())
+    base->mark();
+}
+
+Value ReferenceImp::toPrimitive(ExecState */*exec*/, Type /*preferredType*/) const
+{
+  // invalid for Reference
+  assert(false);
+  return Value();
+}
+
+bool ReferenceImp::toBoolean(ExecState */*exec*/) const
+{
+  // invalid for Reference
+  assert(false);
+  return false;
+}
+
+double ReferenceImp::toNumber(ExecState */*exec*/) const
+{
+  // invalid for Reference
+  assert(false);
+  return 0;
+}
+
+UString ReferenceImp::toString(ExecState */*exec*/) const
+{
+  // invalid for Reference
+  assert(false);
+  return UString::null;
+}
+
+Object ReferenceImp::toObject(ExecState */*exec*/) const
+{
+  // invalid for Reference
+  assert(false);
+  return Object();
+}
+
+// ------------------------------ LabelStack -----------------------------------
+
+LabelStack::LabelStack(const LabelStack &other)
+{
+  tos = 0;
+  *this = other;
+}
+
+LabelStack &LabelStack::operator=(const LabelStack &other)
+{
+  clear();
+  tos = 0;
+  StackElem *cur = 0;
+  StackElem *se = other.tos;
+  while (se) {
+    StackElem *newPrev = new StackElem;
+    newPrev->prev = 0;
+    newPrev->id = se->id;
+    if (cur)
+      cur->prev = newPrev;
+    else
+      tos = newPrev;
+    cur = newPrev;
+    se = se->prev;
+  }
+  return *this;
+}
+
+bool LabelStack::push(const UString &id)
+{
+  if (id.isEmpty() || contains(id))
+    return false;
+
+  StackElem *newtos = new StackElem;
+  newtos->id = id;
+  newtos->prev = tos;
+  tos = newtos;
+  return true;
+}
+
+bool LabelStack::contains(const UString &id) const
+{
+  if (id.isEmpty())
+    return true;
+
+  for (StackElem *curr = tos; curr; curr = curr->prev)
+    if (curr->id == id)
+      return true;
+
+  return false;
+}
+
+void LabelStack::pop()
+{
+  if (tos) {
+    StackElem *prev = tos->prev;
+    delete tos;
+    tos = prev;
+  }
+}
+
+LabelStack::~LabelStack()
+{
+  clear();
+}
+
+void LabelStack::clear()
+{
+  StackElem *prev;
+
+  while (tos) {
+    prev = tos->prev;
+    delete tos;
+    tos = prev;
+  }
+}
+
+// ------------------------------ CompletionImp --------------------------------
+
+CompletionImp::CompletionImp(ComplType c, const Value& v, const UString& t)
+  : comp(c), val(v.imp()), tar(t)
+{
+}
+
+CompletionImp::~CompletionImp()
+{
+}
+
+void CompletionImp::mark()
+{
+  ValueImp::mark();
+
+  if (val && !val->marked())
+    val->mark();
+}
+
+Value CompletionImp::toPrimitive(ExecState */*exec*/, Type /*preferredType*/) const
+{
+  // invalid for Completion
+  assert(false);
+  return Value();
+}
+
+bool CompletionImp::toBoolean(ExecState */*exec*/) const
+{
+  // invalid for Completion
+  assert(false);
+  return false;
+}
+
+double CompletionImp::toNumber(ExecState */*exec*/) const
+{
+  // invalid for Completion
+  assert(false);
+  return 0;
+}
+
+UString CompletionImp::toString(ExecState */*exec*/) const
+{
+  // invalid for Completion
+  assert(false);
+  return UString::null;
+}
+
+Object CompletionImp::toObject(ExecState */*exec*/) const
+{
+  // invalid for Completion
+  assert(false);
+  return Object();
+}
+
+// ------------------------------ ListImp --------------------------------------
+
+#ifdef KJS_DEBUG_MEM
+int ListImp::count = 0;
+#endif
+
+Value ListImp::toPrimitive(ExecState */*exec*/, Type /*preferredType*/) const
+{
+  // invalid for List
+  assert(false);
+  return Value();
+}
+
+bool ListImp::toBoolean(ExecState */*exec*/) const
+{
+  // invalid for List
+  assert(false);
+  return false;
+}
+
+double ListImp::toNumber(ExecState */*exec*/) const
+{
+  // invalid for List
+  assert(false);
+  return 0;
+}
+
+UString ListImp::toString(ExecState */*exec*/) const
+{
+  // invalid for List
+  assert(false);
+  return UString::null;
+}
+
+Object ListImp::toObject(ExecState */*exec*/) const
+{
+  // invalid for List
+  assert(false);
+  return Object();
+}
+
+ListImp::ListImp()
+{
+#ifdef KJS_DEBUG_MEM
+  count++;
+#endif
+
+  hook = new ListNode(Null(), 0L, 0L);
+  hook->next = hook;
+  hook->prev = hook;
+  //fprintf(stderr,"ListImp::ListImp %p hook=%p\n",this,hook);
+}
+
+ListImp::~ListImp()
+{
+  //fprintf(stderr,"ListImp::~ListImp %p\n",this);
+#ifdef KJS_DEBUG_MEM
+  count--;
+#endif
+
+  clear();
+  delete hook;
+}
+
+void ListImp::mark()
+{
+  ListNode *n = hook->next;
+  while (n != hook) {
+    if (!n->member->marked())
+      n->member->mark();
+    n = n->next;
+  }
+  ValueImp::mark();
+}
+
+void ListImp::append(const Value& obj)
+{
+  ListNode *n = new ListNode(obj, hook->prev, hook);
+  hook->prev->next = n;
+  hook->prev = n;
+}
+
+void ListImp::prepend(const Value& obj)
+{
+  ListNode *n = new ListNode(obj, hook, hook->next);
+  hook->next->prev = n;
+  hook->next = n;
+}
+
+void ListImp::appendList(const List& lst)
+{
+  ListIterator it = lst.begin();
+  ListIterator e = lst.end();
+  while(it != e) {
+    append(*it);
+    ++it;
+  }
+}
+
+void ListImp::prependList(const List& lst)
+{
+  ListIterator it = lst.end();
+  ListIterator e = lst.begin();
+  while(it != e) {
+    --it;
+    prepend(*it);
+  }
+}
+
+void ListImp::removeFirst()
+{
+  erase(hook->next);
+}
+
+void ListImp::removeLast()
+{
+  erase(hook->prev);
+}
+
+void ListImp::remove(const Value &obj)
+{
+  if (obj.isNull())
+    return;
+  ListNode *n = hook->next;
+  while (n != hook) {
+    if (n->member == obj.imp()) {
+      erase(n);
+      return;
+    }
+    n = n->next;
+  }
+}
+
+void ListImp::clear()
+{
+  ListNode *n = hook->next;
+  while (n != hook) {
+    n = n->next;
+    delete n->prev;
+  }
+
+  hook->next = hook;
+  hook->prev = hook;
+}
+
+ListImp *ListImp::copy() const
+{
+  ListImp* newList = new ListImp;
+
+  ListIterator e = end();
+  ListIterator it = begin();
+
+  while(it != e) {
+    newList->append(*it);
+    ++it;
+  }
+
+  //fprintf( stderr, "ListImp::copy returning newList=%p\n", newList );
+  return newList;
+}
+
+void ListImp::erase(ListNode *n)
+{
+  if (n != hook) {
+    n->next->prev = n->prev;
+    n->prev->next = n->next;
+    delete n;
+  }
+}
+
+bool ListImp::isEmpty() const
+{
+  return (hook->prev == hook);
+}
+
+int ListImp::size() const
+{
+  int s = 0;
+  ListNode *node = hook;
+  while ((node = node->next) != hook)
+    s++;
+
+  return s;
+}
+
+Value ListImp::at(int i) const
+{
+  if (i < 0 || i >= size())
+    return Undefined();
+
+  ListIterator it = begin();
+  int j = 0;
+  while ((j++ < i))
+    it++;
+
+  return *it;
+}
+
+ListImp *ListImp::emptyList = 0L;
+
+ListImp *ListImp::empty()
+{
+  if (!emptyList)
+    emptyList = new ListImp();
+  return emptyList;
+}
+
+// ------------------------------ ContextImp -----------------------------------
+
 
 // ECMA 10.2
-Context::Context(CodeType type, Context *callingContext,
-                 FunctionImp *func, const List *args, Imp *thisV)
-{
-  Global glob(Global::current());
+ContextImp::ContextImp(Object &glob, ExecState *exec, Object &thisV, CodeType type,
+                       ContextImp *_callingContext, FunctionImp *func, const List &args)
+{
+  codeType = type;
+  callingCon = _callingContext;
 
   // create and initialize activation object (ECMA 10.1.6)
-  if (type == FunctionCode || type == AnonymousCode || type == HostCode) {
-    activation = new ActivationImp(func, args);
+  if (type == FunctionCode || type == AnonymousCode ) {
+    activation = Object(new ActivationImp(exec,func,args));
     variable = activation;
   } else {
-    activation = KJSO();
+    activation = Object();
     variable = glob;
   }
@@ -254 +640 @@
   switch(type) {
     case EvalCode:
-      if (callingContext) {
-        scopeChain = callingContext->copyOfChain();
-        variable = callingContext->variableObject();
-        thisVal = callingContext->thisValue();
+      if (callingCon) {
+        scope = callingCon->scopeChain().copy();
+        variable = callingCon->variableObject();
+        thisVal = callingCon->thisValue();
         break;
       } // else same as GlobalCode
     case GlobalCode:
-      scopeChain = new List();
-      scopeChain->append(glob);
-      thisVal = glob.imp();
+      scope = List();
+      scope.append(glob);
+      thisVal = Object(static_cast<ObjectImp*>(glob.imp()));
       break;
     case FunctionCode:
     case AnonymousCode:
       if (type == FunctionCode) {
-        scopeChain = ((DeclaredFunctionImp*)func)->scopeChain()->copy();
-        scopeChain->prepend(activation);
+        scope = func->scope().copy();
+        scope.prepend(activation);
       } else {
-        scopeChain = new List();
-        scopeChain->append(activation);
-        scopeChain->append(glob);
+        scope = List();
+        scope.append(activation);
+        scope.append(glob);
       }
-      variable = activation; /* TODO: DontDelete ? (ECMA 10.2.3) */
-      if (thisV->type() >= ObjectType) {
-        thisVal = thisV;
-      }
-      else
-        thisVal = glob.imp();
-      break;
-    case HostCode:
-      if (thisV->type() >= ObjectType)
-        thisVal = thisV;
-      else
-        thisVal = glob;
-      variable = activation; /* TODO: DontDelete (ECMA 10.2.4) */
-      scopeChain = new List();
-      scopeChain->append(activation);
-      if (func->hasAttribute(ImplicitThis))
-        scopeChain->append(KJSO(thisVal));
-      if (func->hasAttribute(ImplicitParents)) {
-        /* TODO ??? */
-      }
-      scopeChain->append(glob);
+      variable = activation; // TODO: DontDelete ? (ECMA 10.2.3)
+      thisVal = thisV;
       break;
     }
-}
-
-Context::~Context()
-{
-  delete scopeChain;
-}
-
-Context *Context::current()
-{
-  return KJScriptImp::curr ? KJScriptImp::curr->con : 0L;
-}
-
-void Context::setCurrent(Context *c)
-{
-  KJScriptImp::current()->con = c;
-}
-
-void Context::pushScope(const KJSO &s)
-{
-  scopeChain->prepend(s);
-}
-
-void Context::popScope()
-{
-  scopeChain->removeFirst();
-}
-
-List* Context::copyOfChain()
-{
-  return scopeChain->copy();
-}
-
-
-AnonymousFunction::AnonymousFunction()
-  : Function(0L)
-{
-  /* TODO */
-}
-
-DeclaredFunctionImp::DeclaredFunctionImp(const UString &n,
-                                         FunctionBodyNode *b, const List *sc)
-  : ConstructorImp(n), body(b), scopes(sc->copy())
-{
-}
-
-DeclaredFunctionImp::~DeclaredFunctionImp()
-{
-  delete scopes;
-}
-
-// step 2 of ECMA 13.2.1. rest in FunctionImp::executeCall()
-Completion DeclaredFunctionImp::execute(const List &)
-{
- /* TODO */
-
-#ifdef KJS_DEBUGGER
-  Debugger *dbg = KJScriptImp::current()->debugger();
-  int oldSourceId = -1;
-  if (dbg) {
-    oldSourceId = dbg->sourceId();
-    dbg->setSourceId(body->sourceId());
-  }
+
+}
+
+ContextImp::~ContextImp()
+{
+}
+
+void ContextImp::pushScope(const Object &s)
+{
+  scope.prepend(s);
+}
+
+void ContextImp::popScope()
+{
+  scope.removeFirst();
+}
+
+// ------------------------------ Parser ---------------------------------------
+
+ProgramNode *Parser::progNode = 0;
+int Parser::sid = 0;
+
+ProgramNode *Parser::parse(const UChar *code, unsigned int length, int *sourceId,
+                           int *errLine, UString *errMsg)
+{
+  if (errLine)
+    *errLine = -1;
+  if (errMsg)
+    *errMsg = 0;
+
+  Lexer::curr()->setCode(code, length);
+  progNode = 0;
+  sid++;
+  if (sourceId)
+    *sourceId = sid;
+  // Enable this (and the #define YYDEBUG in grammar.y) to debug a parse error
+  //extern int kjsyydebug;
+  //kjsyydebug=1;
+  int parseError = kjsyyparse();
+  ProgramNode *prog = progNode;
+  progNode = 0;
+  sid = -1;
+
+  if (parseError) {
+    int eline = Lexer::curr()->lineNo();
+    if (errLine)
+      *errLine = eline;
+    if (errMsg)
+      *errMsg = "Parse error at line " + UString::from(eline);
+#ifndef NDEBUG
+    fprintf(stderr, "KJS: JavaScript parse error at line %d.\n", eline);
 #endif
-
-  Completion result = body->execute();
-
-#ifdef KJS_DEBUGGER
-  if (dbg) {
-    dbg->setSourceId(oldSourceId);
-  }
-#endif
-
-  if (result.complType() == Throw || result.complType() == ReturnValue)
-      return result;
-  return Completion(Normal, Undefined()); /* TODO: or ReturnValue ? */
-}
-
-// ECMA 13.2.2 [[Construct]]
-Object DeclaredFunctionImp::construct(const List &args)
-{
-  Object obj(ObjectClass);
-  KJSO p = get("prototype");
-  if (p.isObject())
-    obj.setPrototype(p);
-  else
-    obj.setPrototype(Global::current().objectPrototype());
-
-  KJSO res = executeCall(obj.imp(), &args);
-
-  Object v = Object::dynamicCast(res);
-  if (v.isNull())
-    return obj;
-  else
-    return v;
-}
-
-Completion AnonymousFunction::execute(const List &)
-{
- /* TODO */
-  return Completion(Normal, Null());
-}
-
-// ECMA 10.1.8
-class ArgumentsObject : public ObjectImp {
-public:
-  ArgumentsObject(FunctionImp *func, const List *args);
-};
-
-ArgumentsObject::ArgumentsObject(FunctionImp *func, const List *args)
-  : ObjectImp(UndefClass)
-{
-  put("callee", Function(func), DontEnum);
-  if (args) {
-    put("length", Number(args->size()), DontEnum);
-    ListIterator arg = args->begin();
-    for (int i = 0; arg != args->end(); arg++, i++) {
-      put(UString::from(i), *arg, DontEnum);
-    }
-  }
-}
-
-const TypeInfo ActivationImp::info = { "Activation", ActivationType, 0, 0, 0 };
-
-// ECMA 10.1.6
-ActivationImp::ActivationImp(FunctionImp *f, const List *args)
-{
-  KJSO aobj(new ArgumentsObject(f, args));
-  put("arguments", aobj, DontDelete);
-  /* TODO: this is here to get myFunc.arguments and myFunc.a1 going.
-     I can't see this described in the spec but it's possible in browsers. */
-  if (!f->name().isNull())
-    f->put("arguments", aobj);
-}
-
-ExecutionStack::ExecutionStack()
-  : progNode(0L), firstNode(0L), prev(0)
-{
-}
-
-ExecutionStack* ExecutionStack::push()
-{
-  ExecutionStack *s = new ExecutionStack();
-  s->prev = this;
-
-  return s;
-}
-
-ExecutionStack* ExecutionStack::pop()
-{
-  ExecutionStack *s = prev;
-  delete this;
-
-  return s;
-}
-
-KJScriptImp* KJScriptImp::curr = 0L;
-KJScriptImp* KJScriptImp::hook = 0L;
-int          KJScriptImp::instances = 0;
-int          KJScriptImp::running = 0;
-
-KJScriptImp::KJScriptImp(KJScript *s)
-  : scr(s),
-    initialized(false),
-    glob(0L),
-#ifdef KJS_DEBUGGER
-    dbg(0L),
-#endif
-    retVal(0L)
-{
-  instances++;
-  KJScriptImp::curr = this;
-  // are we the first interpreter instance ? Initialize some stuff
-  if (instances == 1)
-    globalInit();
-  stack = new ExecutionStack();
-  clearException();
-  lex = new Lexer();
-}
-
-KJScriptImp::~KJScriptImp()
-{
-  KJScriptImp::curr = this;
-
-#ifdef KJS_DEBUGGER
-  attachDebugger(0L);
-#endif
-
-  clear();
-
-  delete lex;
-  lex = 0L;
-
-  delete stack;
-  stack = 0L;
-
-  KJScriptImp::curr = 0L;
-  // are we the last of our kind ? Free global stuff.
-  if (instances == 1)
-    globalClear();
-  instances--;
-}
-
-void KJScriptImp::globalInit()
-{
+    delete prog;
+    return 0;
+  }
+
+  return prog;
+}
+
+// ------------------------------ InterpreterImp -------------------------------
+
+InterpreterImp* InterpreterImp::s_hook = 0L;
+
+void InterpreterImp::globalInit()
+{
+  //fprintf( stderr, "InterpreterImp::globalInit()\n" );
   UndefinedImp::staticUndefined = new UndefinedImp();
   UndefinedImp::staticUndefined->ref();
@@ -512 +741 @@
 }
 
-void KJScriptImp::globalClear()
-{
+void InterpreterImp::globalClear()
+{
+  //fprintf( stderr, "InterpreterImp::globalClear()\n" );
   UndefinedImp::staticUndefined->deref();
+  UndefinedImp::staticUndefined->setGcAllowed();
   UndefinedImp::staticUndefined = 0L;
   NullImp::staticNull->deref();
+  NullImp::staticNull->setGcAllowed();
   NullImp::staticNull = 0L;
   BooleanImp::staticTrue->deref();
+  BooleanImp::staticTrue->setGcAllowed();
   BooleanImp::staticTrue = 0L;
   BooleanImp::staticFalse->deref();
+  BooleanImp::staticFalse->setGcAllowed();
   BooleanImp::staticFalse = 0L;
 }
 
-void KJScriptImp::mark()
-{
-  if (exVal && !exVal->marked())
-    exVal->mark();
-  if (retVal && !retVal->marked())
-    retVal->mark();
-  UndefinedImp::staticUndefined->mark();
-  NullImp::staticNull->mark();
-  BooleanImp::staticTrue->mark();
-  BooleanImp::staticFalse->mark();
-}
-
-void KJScriptImp::init()
-{
-  KJScriptImp::curr = this;
-
-  clearException();
-  retVal = 0L;
-
-  if (!initialized) {
-    // add this interpreter to the global chain
-    // as a root set for garbage collection
-    if (hook) {
-      prev = hook;
-      next = hook->next;
-      hook->next->prev = this;
-      hook->next = this;
-    } else {
-      hook = next = prev = this;
+InterpreterImp::InterpreterImp(Interpreter *interp, const Object &glob)
+{
+  // add this interpreter to the global chain
+  // as a root set for garbage collection
+  if (s_hook) {
+    prev = s_hook;
+    next = s_hook->next;
+    s_hook->next->prev = this;
+    s_hook->next = this;
+  } else {
+    // This is the first interpreter
+    s_hook = next = prev = this;
+    globalInit();
+  }
+
+  m_interpreter = interp;
+  global = glob;
+  globExec = new ExecState(m_interpreter,0);
+  dbg = 0;
+  m_compatMode = Interpreter::NativeMode;
+
+  // initialize properties of the global object
+
+  // Contructor prototype objects (Object.prototype, Array.prototype etc)
+
+  FunctionPrototypeImp *funcProto = new FunctionPrototypeImp(globExec);
+  b_FunctionPrototype = Object(funcProto);
+  ObjectPrototypeImp *objProto = new ObjectPrototypeImp(globExec,funcProto);
+  b_ObjectPrototype = Object(objProto);
+  funcProto->setPrototype(b_ObjectPrototype);
+
+  ArrayPrototypeImp *arrayProto = new ArrayPrototypeImp(globExec,objProto);
+  b_ArrayPrototype = Object(arrayProto);
+  StringPrototypeImp *stringProto = new StringPrototypeImp(globExec,objProto);
+  b_StringPrototype = Object(stringProto);
+  BooleanPrototypeImp *booleanProto = new BooleanPrototypeImp(globExec,objProto,funcProto);
+  b_BooleanPrototype = Object(booleanProto);
+  NumberPrototypeImp *numberProto = new NumberPrototypeImp(globExec,objProto,funcProto);
+  b_NumberPrototype = Object(numberProto);
+  DatePrototypeImp *dateProto = new DatePrototypeImp(globExec,objProto);
+  b_DatePrototype = Object(dateProto);
+  RegExpPrototypeImp *regexpProto = new RegExpPrototypeImp(globExec,objProto,funcProto);
+  b_RegExpPrototype = Object(regexpProto);
+  ErrorPrototypeImp *errorProto = new ErrorPrototypeImp(globExec,objProto,funcProto);
+  b_ErrorPrototype = Object(errorProto);
+
+  static_cast<ObjectImp*>(global.imp())->setPrototype(b_ObjectPrototype);
+
+  // Constructors (Object, Array, etc.)
+
+  ObjectObjectImp *objectObj = new ObjectObjectImp(globExec,objProto,funcProto);
+  b_Object = Object(objectObj);
+  FunctionObjectImp *funcObj = new FunctionObjectImp(globExec,funcProto);
+  b_Function = Object(funcObj);
+  ArrayObjectImp *arrayObj = new ArrayObjectImp(globExec,funcProto,arrayProto);
+  b_Array = Object(arrayObj);
+  StringObjectImp *stringObj = new StringObjectImp(globExec,funcProto,stringProto);
+  b_String = Object(stringObj);
+  BooleanObjectImp *booleanObj = new BooleanObjectImp(globExec,funcProto,booleanProto);
+  b_Boolean = Object(booleanObj);
+  NumberObjectImp *numberObj = new NumberObjectImp(globExec,funcProto,numberProto);
+  b_Number = Object(numberObj);
+  DateObjectImp *dateObj = new DateObjectImp(globExec,funcProto,dateProto);
+  b_Date = Object(dateObj);
+  RegExpObjectImp *regexpObj = new RegExpObjectImp(globExec,regexpProto,funcProto);
+  b_RegExp = Object(regexpObj);
+  ErrorObjectImp *errorObj = new ErrorObjectImp(globExec,funcProto,errorProto);
+  b_Error = Object(errorObj);
+
+  // Error object prototypes
+  b_evalErrorPrototype = Object(new NativeErrorPrototypeImp(globExec,errorProto,EvalError,
+                                                            "EvalError","EvalError"));
+  b_rangeErrorPrototype = Object(new NativeErrorPrototypeImp(globExec,errorProto,RangeError,
+                                                            "RangeError","RangeError"));
+  b_referenceErrorPrototype = Object(new NativeErrorPrototypeImp(globExec,errorProto,ReferenceError,
+                                                            "ReferenceError","ReferenceError"));
+  b_syntaxErrorPrototype = Object(new NativeErrorPrototypeImp(globExec,errorProto,SyntaxError,
+                                                            "SyntaxError","SyntaxError"));
+  b_typeErrorPrototype = Object(new NativeErrorPrototypeImp(globExec,errorProto,TypeError,
+                                                            "TypeError","TypeError"));
+  b_uriErrorPrototype = Object(new NativeErrorPrototypeImp(globExec,errorProto,URIError,
+                                                            "URIError","URIError"));
+
+  // Error objects
+  b_evalError = Object(new NativeErrorImp(globExec,funcProto,b_evalErrorPrototype));
+  b_rangeError = Object(new NativeErrorImp(globExec,funcProto,b_rangeErrorPrototype));
+  b_referenceError = Object(new NativeErrorImp(globExec,funcProto,b_referenceErrorPrototype));
+  b_syntaxError = Object(new NativeErrorImp(globExec,funcProto,b_syntaxErrorPrototype));
+  b_typeError = Object(new NativeErrorImp(globExec,funcProto,b_typeErrorPrototype));
+  b_uriError = Object(new NativeErrorImp(globExec,funcProto,b_uriErrorPrototype));
+
+  // ECMA 15.3.4.1
+  funcProto->put(globExec,"constructor", b_Function, DontEnum);
+
+  global.put(globExec,"Object", b_Object, DontEnum);
+  global.put(globExec,"Function", b_Function, DontEnum);
+  global.put(globExec,"Array", b_Array, DontEnum);
+  global.put(globExec,"Boolean", b_Boolean, DontEnum);
+  global.put(globExec,"String", b_String, DontEnum);
+  global.put(globExec,"Number", b_Number, DontEnum);
+  global.put(globExec,"Date", b_Date, DontEnum);
+  global.put(globExec,"RegExp", b_RegExp, DontEnum);
+  global.put(globExec,"Error", b_Error, DontEnum);
+  // Using Internal for those to have something != 0
+  // (see kjs_window). Maybe DontEnum would be ok too ?
+  global.put(globExec,"EvalError",b_evalError, Internal);
+  global.put(globExec,"RangeError",b_rangeError, Internal);
+  global.put(globExec,"ReferenceError",b_referenceError, Internal);
+  global.put(globExec,"SyntaxError",b_syntaxError, Internal);
+  global.put(globExec,"TypeError",b_typeError, Internal);
+  global.put(globExec,"URIError",b_uriError, Internal);
+
+  // Set the "constructor" property of all builtin constructors
+  objProto->put(globExec, "constructor", b_Object, DontEnum | DontDelete | ReadOnly);
+  funcProto->put(globExec, "constructor", b_Function, DontEnum | DontDelete | ReadOnly);
+  arrayProto->put(globExec, "constructor", b_Array, DontEnum | DontDelete | ReadOnly);
+  booleanProto->put(globExec, "constructor", b_Boolean, DontEnum | DontDelete | ReadOnly);
+  stringProto->put(globExec, "constructor", b_String, DontEnum | DontDelete | ReadOnly);
+  numberProto->put(globExec, "constructor", b_Number, DontEnum | DontDelete | ReadOnly);
+  dateProto->put(globExec, "constructor", b_Date, DontEnum | DontDelete | ReadOnly);
+  regexpProto->put(globExec, "constructor", b_RegExp, DontEnum | DontDelete | ReadOnly);
+  errorProto->put(globExec, "constructor", b_Error, DontEnum | DontDelete | ReadOnly);
+  b_evalErrorPrototype.put(globExec, "constructor", b_evalError, DontEnum | DontDelete | ReadOnly);
+  b_rangeErrorPrototype.put(globExec, "constructor", b_rangeError, DontEnum | DontDelete | ReadOnly);
+  b_referenceErrorPrototype.put(globExec, "constructor", b_referenceError, DontEnum | DontDelete | ReadOnly);
+  b_syntaxErrorPrototype.put(globExec, "constructor", b_syntaxError, DontEnum | DontDelete | ReadOnly);
+  b_typeErrorPrototype.put(globExec, "constructor", b_typeError, DontEnum | DontDelete | ReadOnly);
+  b_uriErrorPrototype.put(globExec, "constructor", b_uriError, DontEnum | DontDelete | ReadOnly);
+
+  // built-in values
+  global.put(globExec,"NaN",        Number(NaN), DontEnum);
+  global.put(globExec,"Infinity",   Number(Inf), DontEnum);
+  global.put(globExec,"undefined",  Undefined(), DontEnum);
+
+  // built-in functions
+  global.put(globExec,"eval",       Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::Eval,       1)), DontEnum);
+  global.put(globExec,"parseInt",   Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::ParseInt,   2)), DontEnum);
+  global.put(globExec,"parseFloat", Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::ParseFloat, 1)), DontEnum);
+  global.put(globExec,"isNaN",      Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::IsNaN,      1)), DontEnum);
+  global.put(globExec,"isFinite",   Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::IsFinite,   1)), DontEnum);
+  global.put(globExec,"escape",     Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::Escape,     1)), DontEnum);
+  global.put(globExec,"unescape",   Object(new GlobalFuncImp(globExec,funcProto,GlobalFuncImp::UnEscape,   1)), DontEnum);
+
+  // built-in objects
+  global.put(globExec,"Math", Object(new MathObjectImp(globExec,objProto)), DontEnum);
+
+  recursion = 0;
+}
+
+InterpreterImp::~InterpreterImp()
+{
+  if (dbg)
+    dbg->detach(m_interpreter);
+  delete globExec;
+  globExec = 0L;
+  clear();
+}
+
+void InterpreterImp::clear()
+{
+  //fprintf(stderr,"InterpreterImp::clear\n");
+  // remove from global chain (see init())
+  next->prev = prev;
+  prev->next = next;
+  s_hook = next;
+  if (s_hook == this)
+  {
+    // This was the last interpreter
+    s_hook = 0L;
+    globalClear();
+  }
+}
+
+void InterpreterImp::mark()
+{
+  //if (exVal && !exVal->marked())
+  //  exVal->mark();
+  //if (retVal && !retVal->marked())
+  //  retVal->mark();
+  if (UndefinedImp::staticUndefined && !UndefinedImp::staticUndefined->marked())
+    UndefinedImp::staticUndefined->mark();
+  if (NullImp::staticNull && !NullImp::staticNull->marked())
+    NullImp::staticNull->mark();
+  if (BooleanImp::staticTrue && !BooleanImp::staticTrue->marked())
+    BooleanImp::staticTrue->mark();
+  if (BooleanImp::staticFalse && !BooleanImp::staticFalse->marked())
+    BooleanImp::staticFalse->mark();
+  if (ListImp::emptyList && !ListImp::emptyList->marked())
+    ListImp::emptyList->mark();
+  //fprintf( stderr, "InterpreterImp::mark this=%p global.imp()=%p\n", this, global.imp() );
+  if (global.imp())
+    global.imp()->mark();
+  if (m_interpreter)
+    m_interpreter->mark();
+}
+
+bool InterpreterImp::checkSyntax(const UString &code)
+{
+  // Parser::parse() returns 0 in a syntax error occurs, so we just check for that
+  ProgramNode *progNode = Parser::parse(code.data(),code.size(),0,0,0);
+  bool ok = (progNode != 0);
+  delete progNode;
+  return ok;
+}
+
+Completion InterpreterImp::evaluate(const UString &code, const Value &thisV)
+{
+  // prevent against infinite recursion
+  if (recursion >= 20) {
+    return Completion(Throw,Error::create(globExec,GeneralError,"Recursion too deep"));
+  }
+
+  // parse the source code
+  int sid;
+  int errLine;
+  UString errMsg;
+  ProgramNode *progNode = Parser::parse(code.data(),code.size(),&sid,&errLine,&errMsg);
+
+  // notify debugger that source has been parsed
+  if (dbg) {
+    bool cont = dbg->sourceParsed(globExec,sid,code,errLine);
+    if (!cont)
+      return Completion(Break);
+  }
+
+  // no program node means a syntax occurred
+  if (!progNode) {
+    Object err = Error::create(globExec,SyntaxError,errMsg.ascii(),errLine);
+    err.put(globExec,"sid",Number(sid));
+    return Completion(Throw,err);
+  }
+
+  globExec->clearException();
+
+  recursion++;
+  progNode->ref();
+
+  Object globalObj = globalObject();
+  Object thisObj = globalObject();
+
+  if (!thisV.isNull()) {
+    // "this" must be an object... use same rules as Function.prototype.apply()
+    if (thisV.isA(NullType) || thisV.isA(UndefinedType))
+      thisObj = globalObject();
+    else {
+      thisObj = thisV.toObject(globExec);
     }
-
-    glob.init();
-    con = new Context();
-    firstN = 0L;
-    progN = 0L;
-    recursion = 0;
-    errMsg = "";
-    initialized = true;
-#ifdef KJS_DEBUGGER
-    sid = -1;
-#endif
-  }
-}
-
-void KJScriptImp::clear()
-{
-  if ( recursion ) {
-#ifndef NDEBUG
-      fprintf(stderr, "KJS: ignoring clear() while running\n");
-#endif
-      return;
-  }
-  KJScriptImp *old = curr;
-  if (initialized) {
-    KJScriptImp::curr = this;
-
-    Node::setFirstNode(firstNode());
-    Node::deleteAllNodes();
-    setFirstNode(0L);
-    setProgNode(0L);
-
-    clearException();
-    retVal = 0L;
-
-    delete con; con = 0L;
-    glob.clear();
-
-    Collector::collect();
-
-    // remove from global chain (see init())
-    next->prev = prev;
-    prev->next = next;
-    hook = next;
-    if (hook == this)
-      hook = 0L;
-
-#ifdef KJS_DEBUGGER
-    sid = -1;
-#endif
-
-    initialized = false;
-  }
-  if (old != this)
-      KJScriptImp::curr = old;
-}
-
-bool KJScriptImp::evaluate(const UChar *code, unsigned int length, const KJSO &thisV,
-                           bool onlyCheckSyntax)
-{
-  init();
-
-#ifdef KJS_DEBUGGER
-  sid++;
-  if (debugger())
-    debugger()->setSourceId(sid);
-#endif
-  if (recursion > 7) {
-    fprintf(stderr, "KJS: breaking out of recursion\n");
-    return true;
-  } else if (recursion > 0) {
-#ifndef NDEBUG
-    fprintf(stderr, "KJS: entering recursion level %d\n", recursion);
-#endif
-    pushStack();
-  }
-
-  assert(Lexer::curr());
-  Lexer::curr()->setCode(code, length);
-  Node::setFirstNode(firstNode());
-  int parseError = kjsyyparse();
-  setFirstNode(Node::firstNode());
-
-  if (parseError) {
-    errType = 99; /* TODO */
-    errLine = Lexer::curr()->lineNo();
-    errMsg = "Parse error at line " + UString::from(errLine);
-#ifndef NDEBUG
-    fprintf(stderr, "JavaScript parse error at line %d.\n", errLine);
-#endif
-    /* TODO: either clear everything or keep previously
-       parsed function definitions */
-    //    Node::deleteAllNodes();
-    return false;
-  }
-
-  if (onlyCheckSyntax)
-      return true;
-
-  clearException();
-
-  KJSO oldVar;
-  if (!thisV.isNull()) {
-    context()->setThisValue(thisV);
-    context()->pushScope(thisV);
-    oldVar = context()->variableObject();
-    context()->setVariableObject(thisV);
-  }
-
-  running++;
-  recursion++;
-  assert(progNode());
-  Completion res = progNode()->execute();
+  }
+
+  Completion res;
+  if (globExec->hadException()) {
+    // the thisArg.toObject() conversion above might have thrown an exception - if so,
+    // propagate it back
+    res = Completion(Throw,globExec->exception());
+  }
+  else {
+    // execute the code
+    ExecState *exec1 = 0;
+    ContextImp *ctx = new ContextImp(globalObj, exec1, thisObj);
+    ExecState *newExec = new ExecState(m_interpreter,ctx);
+
+    res = progNode->execute(newExec);
+
+    delete newExec;
+    delete ctx;
+  }
+
+  if (progNode->deref())
+    delete progNode;
   recursion--;
-  running--;
-
-  if (hadException()) {
-    KJSO err = exception();
-    errType = 99; /* TODO */
-    errLine = err.get("line").toInt32();
-    errMsg = err.get("name").toString().value() + ". ";
-    errMsg += err.get("message").toString().value();
-#ifdef KJS_DEBUGGER
-    if (dbg)
-      dbg->setSourceId(err.get("sid").toInt32());
-#endif
-    clearException();
-  } else {
-    errType = 0;
-    errLine = -1;
-    errMsg = "";
-
-    // catch return value
-    retVal = 0L;
-    if (res.complType() == ReturnValue || !thisV.isNull())
-        retVal = res.value().imp();
-  }
-
-  if (!thisV.isNull()) {
-    context()->popScope();
-    context()->setVariableObject(oldVar);
-  }
-
-  if (progNode())
-    progNode()->deleteGlobalStatements();
-
-  if (recursion > 0) {
-    popStack();
-  }
-
-  return !errType;
-}
-
-void KJScriptImp::pushStack()
-{
-    stack = stack->push();
-}
-
-void KJScriptImp::popStack()
-{
-    stack = stack->pop();
-    assert(stack);
-}
-
-bool KJScriptImp::call(const KJSO &scope, const UString &func, const List &args)
-{
-  init();
-  KJSO callScope(scope);
-  if (callScope.isNull())
-    callScope = Global::current().imp();
-  if (!callScope.hasProperty(func)) {
-#ifndef NDEBUG
-      fprintf(stderr, "couldn't resolve function name %s. call() failed\n",
-              func.ascii());
-#endif
-      return false;
-  }
-  KJSO v = callScope.get(func);
-  if (!v.isA(ConstructorType)) {
-#ifndef NDEBUG
-      fprintf(stderr, "%s is not a function. call() failed.\n", func.ascii());
-#endif
-      return false;
-  }
-  running++;
-  recursion++;
-  static_cast<ConstructorImp*>(v.imp())->executeCall(scope.imp(), &args);
-  recursion--;
-  running--;
-  return !hadException();
-}
-
-bool KJScriptImp::call(const KJSO &func, const KJSO &thisV,
-                       const List &args, const List &extraScope)
-{
-  init();
-  if(!func.implementsCall())
-    return false;
-
-  running++;
-  recursion++;
-  retVal = func.executeCall(thisV, &args, &extraScope).imp();
-  recursion--;
-  running--;
-
-  return !hadException();
-}
-
-void KJScriptImp::setException(Imp *e)
-{
-  assert(curr);
-  curr->exVal = e;
-  curr->exMsg = "Exception"; // not very meaningful but we use !0L to test
-}
-
-void KJScriptImp::setException(const char *msg)
-{
-  assert(curr);
-  curr->exVal = 0L;             // will be created later on exception()
-  curr->exMsg = msg;
-}
-
-KJSO KJScriptImp::exception()
-{
-  assert(curr);
-  if (!curr->exMsg)
-    return Undefined();
-  if (curr->exVal)
-    return curr->exVal;
-  return Error::create(GeneralError, curr->exMsg);
-}
-
-void KJScriptImp::clearException()
-{
-  assert(curr);
-  curr->exMsg = 0L;
-  curr->exVal = 0L;
-}
-
-#ifdef KJS_DEBUGGER
-void KJScriptImp::attachDebugger(Debugger *d)
-{
-  static bool detaching = false;
-  if (detaching) // break circular detaching
-    return;
-
-  if (dbg) {
-    detaching = true;
-    dbg->detach();
-    detaching = false;
-  }
-
+
+  return res;
+}
+
+void InterpreterImp::setDebugger(Debugger *d)
+{
+  if (d)
+    d->detach(m_interpreter);
   dbg = d;
 }
 
-bool KJScriptImp::setBreakpoint(int id, int line, bool set)
-{
-  init();
-  return Node::setBreakpoint(firstNode(), id, line, set);
-}
-
-#endif
-
-bool PropList::contains(const UString &name)
-{
-  PropList *p = this;
-  while (p) {
-    if (name == p->name)
-      return true;
-    p = p->next;
-  }
-  return false;
-}
-
-bool LabelStack::push(const UString &id)
-{
-  if (id.isEmpty() || contains(id))
-    return false;
-
-  StackElm *newtos = new StackElm;
-  newtos->id = id;
-  newtos->prev = tos;
-  tos = newtos;
+// ------------------------------ InternalFunctionImp --------------------------
+
+const ClassInfo InternalFunctionImp::info = {"Function", 0, 0, 0};
+
+InternalFunctionImp::InternalFunctionImp(FunctionPrototypeImp *funcProto)
+  : ObjectImp(Object(funcProto))
+{
+}
+
+bool InternalFunctionImp::implementsHasInstance() const
+{
   return true;
 }
 
-bool LabelStack::contains(const UString &id) const
-{
-  if (id.isEmpty())
-    return true;
-
-  for (StackElm *curr = tos; curr; curr = curr->prev)
-    if (curr->id == id)
-      return true;
-
-  return false;
-}
-
-void LabelStack::pop()
-{
-  if (tos) {
-    StackElm *prev = tos->prev;
-    delete tos;
-    tos = prev;
-  }
-}
-
-LabelStack::~LabelStack()
-{
-  StackElm *prev;
-
-  while (tos) {
-    prev = tos->prev;
-    delete tos;
-    tos = prev;
-  }
-}
-
-// ECMA 15.3.5.3 [[HasInstance]]
-// see comment in header file
-KJSO KJS::hasInstance(const KJSO &F, const KJSO &V)
-{
-  if (V.isObject()) {
-    KJSO prot = F.get("prototype");
-    if (!prot.isObject())
-      return Error::create(TypeError, "Invalid prototype encountered "
-                           "in instanceof operation.");
-    Imp *v = V.imp();
-    while ((v = v->prototype())) {
-      if (v == prot.imp())
-        return Boolean(true);
-    }
+Boolean InternalFunctionImp::hasInstance(ExecState *exec, const Value &value)
+{
+  if (value.type() != ObjectType)
+    return Boolean(false);
+
+  Value prot = get(exec,"prototype");
+  if (prot.type() != ObjectType && prot.type() != NullType) {
+    Object err = Error::create(exec, TypeError, "Invalid prototype encountered "
+                               "in instanceof operation.");
+    exec->setException(err);
+    return Boolean(false);
+  }
+
+  Object v = Object(static_cast<ObjectImp*>(value.imp()));
+  while ((v = Object::dynamicCast(v.prototype())).imp()) {
+    if (v.imp() == prot.imp())
+      return Boolean(true);
   }
   return Boolean(false);
+}
+
+// ------------------------------ global functions -----------------------------
+
+double KJS::roundValue(ExecState *exec, const Value &v)
+{
+  if (v.type() == UndefinedType) /* TODO: see below */
+    return 0.0;
+  Number n = v.toNumber(exec);
+  if (n.value() == 0.0)   /* TODO: -0, NaN, Inf */
+    return 0.0;
+  double d = floor(fabs(n.value()));
+  if (n.value() < 0)
+    d *= -1;
+
+  return d;
 }
 
 #ifndef NDEBUG
 #include <stdio.h>
-void KJS::printInfo( const char *s, const KJSO &o )
-{
-    if (o.isNull())
-      fprintf(stderr, "%s: (null)\n", s);
-    else {
-      KJSO v = o;
-      if (o.isA(ReferenceType))
-          v = o.getValue();
-      fprintf(stderr, "JS: %s: %s : %s (%p)\n",
-              s,
-              v.toString().value().ascii(),
-              v.imp()->typeInfo()->name,
-              (void*)v.imp());
+void KJS::printInfo(ExecState *exec, const char *s, const Value &o, int lineno)
+{
+  if (o.isNull())
+    fprintf(stderr, "KJS: %s: (null)", s);
+  else {
+    Value v = o;
+    if (o.isA(ReferenceType))
+      v = o.getValue(exec);
+
+    UString name;
+    switch ( v.type() ) {
+    case UnspecifiedType:
+      name = "Unspecified";
+      break;
+    case UndefinedType:
+      name = "Undefined";
+      break;
+    case NullType:
+      name = "Null";
+      break;
+    case BooleanType:
+      name = "Boolean";
+      break;
+    case StringType:
+      name = "String";
+      break;
+    case NumberType:
+      name = "Number";
+      break;
+    case ObjectType:
+      name = Object::dynamicCast(v).className();
+      if (name.isNull())
+        name = "(unknown class)";
+      break;
+    case ReferenceType:
+      name = "Reference";
+      break;
+    case ListType:
+      name = "List";
+      break;
+    case CompletionType:
+      name = "Completion";
+      break;
+    default:
+      break;
+    }
+    UString vString = v.toString(exec);
+    if ( vString.size() > 50 )
+      vString = vString.substr( 0, 50 ) + "...";
+    // Can't use two UString::ascii() in the same fprintf call
+    CString tempString( vString.cstring() );
+
+    fprintf(stderr, "KJS: %s: %s : %s (%p)",
+            s, tempString.c_str(), name.ascii(), (void*)v.imp());
+
+    if (lineno >= 0)
+      fprintf(stderr, ", line %d\n",lineno);
+    else
+      fprintf(stderr, "\n");
+    if (!o.isNull())
       if (o.isA(ReferenceType)) {
-          fprintf(stderr, "JS: Was property '%s'\n", o.getPropertyName().ascii());
-          printInfo("of", o.getBase());
+        fprintf(stderr, "KJS: Was property '%s'\n", o.getPropertyName(exec).ascii());
+        printInfo(exec,"of", o.getBase(exec));
       }
-    }
+  }
 }
 #endif

trunk/JavaScriptCore/kjs/internal.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
  */
 
@@ -22 +25 @@
 #define _INTERNAL_H_
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
-
-#include "kjs.h"
+#include "ustring.h"
+#include "value.h"
 #include "object.h"
-#include "function.h"
+#include "types.h"
+#include "interpreter.h"
 
 #define I18N_NOOP(s) s
@@ -34 +35 @@
 namespace KJS {
 
-  class Boolean;
-  class Number;
-  class String;
-  class Object;
-  class RegExp;
-  class Node;
+  static const double D16 = 65536.0;
+  static const double D32 = 4294967296.0;
+
+  class ProgramNode;
   class FunctionBodyNode;
-  class ProgramNode;
-#ifdef KJS_DEBUGGER
+  class FunctionPrototypeImp;
+  class FunctionImp;
   class Debugger;
-#endif
-
-  class UndefinedImp : public Imp {
-  public:
-    UndefinedImp();
+
+  // ---------------------------------------------------------------------------
+  //                            Primitive impls
+  // ---------------------------------------------------------------------------
+
+  class UndefinedImp : public ValueImp {
+  public:
+    UndefinedImp() {}
     virtual ~UndefinedImp() { }
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const;
-    virtual Boolean toBoolean() const;
-    virtual Number toNumber() const;
-    virtual String toString() const;
-    virtual Object toObject() const;
-
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-      
+
+    Type type() const { return UndefinedType; }
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
     static UndefinedImp *staticUndefined;
   };
 
-  class NullImp : public Imp {
-  public:
-    NullImp();
+  class NullImp : public ValueImp {
+  public:
+    NullImp() {}
     virtual ~NullImp() { }
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const;
-    virtual Boolean toBoolean() const;
-    virtual Number toNumber() const;
-    virtual String toString() const;
-    virtual Object toObject() const;
-
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
+
+    Type type() const { return NullType; }
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
 
     static NullImp *staticNull;
   };
 
-  class BooleanImp : public Imp {
+  class BooleanImp : public ValueImp {
   public:
     virtual ~BooleanImp() { }
     BooleanImp(bool v = false) : val(v) { }
     bool value() const { return val; }
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const;
-    virtual Boolean toBoolean() const;
-    virtual Number toNumber() const;
-    virtual String toString() const;
-    virtual Object toObject() const;
-
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-
-    static BooleanImp *staticTrue, *staticFalse;
+
+    Type type() const { return BooleanType; }
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
+    static BooleanImp *staticTrue;
+    static BooleanImp *staticFalse;
   private:
     bool val;
   };
 
-  class NumberImp : public Imp {
+  class StringImp : public ValueImp {
+  public:
+    StringImp(const UString& v);
+    virtual ~StringImp() { }
+    UString value() const { return val; }
+
+    Type type() const { return StringType; }
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
+  private:
+    UString val;
+  };
+
+  class NumberImp : public ValueImp {
   public:
     NumberImp(double v);
     virtual ~NumberImp() { }
     double value() const { return val; }
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const;
-    virtual Boolean toBoolean() const;
-    virtual Number toNumber() const;
-    virtual String toString() const;
-    virtual Object toObject() const;
-
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
+
+    Type type() const { return NumberType; }
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
   private:
     double val;
   };
 
-  class StringImp : public Imp {
-  public:
-    StringImp(const UString& v);
-    virtual ~StringImp() { }
-    UString value() const { return val; }
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const;
-    virtual Boolean toBoolean() const;
-    virtual Number toNumber() const;
-    virtual String toString() const;
-    virtual Object toObject() const;
-
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-  private:
-    UString val;
-  };
-
-  class ReferenceImp : public Imp {
-  public:
-    ReferenceImp(const KJSO& b, const UString& p);
+  // ---------------------------------------------------------------------------
+  //                            Internal type impls
+  // ---------------------------------------------------------------------------
+
+  class ReferenceImp : public ValueImp {
+  public:
+
+    ReferenceImp(const Value& v, const UString& p);
     virtual ~ReferenceImp() { }
-    virtual void mark(Imp*);
-    KJSO getBase() const { return base; }
+    virtual void mark();
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
+    Value getBase() const { return Value(base); }
     UString getPropertyName() const { return prop; }
 
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-  private:
-    KJSO base;
+    Type type() const { return ReferenceType; }
+
+  private:
+    ValueImp *base;
     UString prop;
   };
 
-  class CompletionImp : public Imp {
-  public:
-    CompletionImp(Compl c, const KJSO& v, const UString& t);
-    virtual ~CompletionImp() { }
-    virtual void mark(Imp*);
-    Compl completion() const { return comp; }
-    KJSO value() const { return val; }
+  class CompletionImp : public ValueImp {
+  public:
+    Type type() const { return CompletionType; }
+
+    CompletionImp(ComplType c, const Value& v, const UString& t);
+    virtual ~CompletionImp();
+    virtual void mark();
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
+    ComplType complType() const { return comp; }
+    Value value() const { return Value(val); }
     UString target() const { return tar; }
 
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-  private:
-    Compl comp;
-    KJSO val;
+  private:
+    ComplType comp;
+    ValueImp * val;
     UString tar;
   };
 
-  class RegExpImp : public ObjectImp {
-  public:
-    RegExpImp();
-    ~RegExpImp();
-    void setRegExp(RegExp *r) { reg = r; }
-    RegExp* regExp() const { return reg; }
-  private:
-    RegExp *reg;
-  };
-
-  class StatementNode;
-  class UString;
-
-  class Reference : public KJSO {
-  public:
-    Reference(const KJSO& b, const UString &p);
-    virtual ~Reference();
+  /**
+   * @internal
+   */
+  class ListNode {
+    friend class List;
+    friend class ListImp;
+    friend class ListIterator;
+    ListNode(Value val, ListNode *p, ListNode *n)
+      : member(val.imp()), prev(p), next(n) {};
+    ValueImp *member;
+    ListNode *prev, *next;
+  };
+
+  class ListImp : public ValueImp {
+    friend class ListIterator;
+    friend class List;
+    friend class InterpreterImp;
+  public:
+    ListImp();
+    ~ListImp();
+
+    Type type() const { return ListType; }
+
+    virtual void mark();
+
+    Value toPrimitive(ExecState *exec, Type preferred = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
+    void append(const Value& val);
+    void prepend(const Value& val);
+    void appendList(const List& lst);
+    void prependList(const List& lst);
+    void removeFirst();
+    void removeLast();
+    void remove(const Value &val);
+    void clear();
+    ListImp *copy() const;
+    ListIterator begin() const { return ListIterator(hook->next); }
+    ListIterator end() const { return ListIterator(hook); }
+    //    bool isEmpty() const { return (hook->prev == hook); }
+    bool isEmpty() const;
+    int size() const;
+    Value at(int i) const;
+    Value operator[](int i) const { return at(i); }
+    static ListImp* empty();
+
+#ifdef KJS_DEBUG_MEM
+    static int count;
+#endif
+  private:
+    void erase(ListNode *n);
+    ListNode *hook;
+    static ListImp *emptyList;
   };
 
@@ -189 +252 @@
     LabelStack(): tos(0L) {}
     ~LabelStack();
+
+    LabelStack(const LabelStack &other);
+    LabelStack &operator=(const LabelStack &other);
 
     /**
@@ -204 +270 @@
     void pop();
   private:
-    struct StackElm {
+    struct StackElem {
       UString id;
-      StackElm *prev;
+      StackElem *prev;
     };
 
-    StackElm *tos;
-  };
+    StackElem *tos;
+    void clear();
+  };
+
+
+  // ---------------------------------------------------------------------------
+  //                            Parsing & evaluateion
+  // ---------------------------------------------------------------------------
+
+  enum CodeType { GlobalCode,
+                  EvalCode,
+                  FunctionCode,
+                  AnonymousCode };
 
   /**
    * @short Execution context.
    */
-  class Context {
-  public:
-    Context(CodeType type = GlobalCode, Context *callingContext = 0L,
-               FunctionImp *func = 0L, const List *args = 0L, Imp *thisV = 0L);
-    virtual ~Context();
-    static Context *current();
-    static void setCurrent(Context *c);
-    const List *pScopeChain() const { return scopeChain; }
-    void pushScope(const KJSO &s);
+  class ContextImp {
+  public:
+    ContextImp(Object &glob, ExecState *exec, Object &thisV, CodeType type = GlobalCode,
+               ContextImp *_callingContext = 0L, FunctionImp *func = 0L, const List &args = List());
+    virtual ~ContextImp();
+
+    const List scopeChain() const { return scope; }
+    Object variableObject() const { return variable; }
+    void setVariableObject(const Object &v) { variable = v; }
+    Object thisValue() const { return thisVal; }
+    ContextImp *callingContext() { return callingCon; }
+    Object activationObject() { return activation; }
+
+    void pushScope(const Object &s);
     void popScope();
-    List *copyOfChain();
-    KJSO variableObject() const { return variable; }
-    void setVariableObject( const KJSO &obj ) { variable = obj; }
-    KJSO thisValue() const { return thisVal; }
-    void setThisValue(const KJSO &t) { thisVal = t; }
     LabelStack *seenLabels() { return &ls; }
-  private:
+
+  private:
+
+    List scope;
+    Object variable;
+    Object thisVal;
+    ContextImp *callingCon;
+    Object activation;
+
+
     LabelStack ls;
-    KJSO thisVal;
-    KJSO activation;
-    KJSO variable;
-    List *scopeChain;
-  };
-
-  class DeclaredFunctionImp : public ConstructorImp {
-  public:
-    DeclaredFunctionImp(const UString &n, FunctionBodyNode *b,
-                        const List *sc);
-    ~DeclaredFunctionImp();
-    Completion execute(const List &);
-    Object construct(const List &);
-    CodeType codeType() const { return FunctionCode; }
-    List *scopeChain() const { return scopes; }
-  private:
-    FunctionBodyNode *body;
-    List *scopes;
-  };
-
-  class AnonymousFunction : public Function {
-  public:
-    AnonymousFunction();
-    Completion execute(const List &);
-    CodeType codeType() const { return AnonymousCode; }
-  };
-
-  class ActivationImp : public Imp {
-  public:
-    ActivationImp(FunctionImp *f, const List *args);
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-  };
-
-  class ExecutionStack {
-  public:
-    ExecutionStack();
-    ExecutionStack *push();
-    ExecutionStack *pop();
-    
-    ProgramNode *progNode;
-    Node *firstNode;
-  private:
-    ExecutionStack *prev;
-  };
-
-  class KJScriptImp {
-    friend class ::KJScript;
-    friend class Lexer;
-    friend class Context;
-    friend class Global;
+    CodeType codeType;
+  };
+
+  /**
+   * @internal
+   *
+   * Parses ECMAScript source code and converts into ProgramNode objects, which
+   * represent the root of a parse tree. This class provides a conveniant workaround
+   * for the problem of the bison parser working in a static context.
+   */
+  class Parser {
+  public:
+    static ProgramNode *parse(const UChar *code, unsigned int length, int *sourceId = 0,
+                              int *errLine = 0, UString *errMsg = 0);
+
+    static ProgramNode *progNode;
+    static int sid;
+  };
+
+  class InterpreterImp {
     friend class Collector;
   public:
-    KJScriptImp(KJScript *s);
-    ~KJScriptImp();
+    static void globalInit();
+    static void globalClear();
+
+    InterpreterImp(Interpreter *interp, const Object &glob);
+    ~InterpreterImp();
+
+    Object globalObject() const { return global; }
+    Interpreter* interpreter() const { return m_interpreter; }
+
     void mark();
-    static KJScriptImp *current() { return curr; }
-    static void setException(Imp *e);
-    static void setException(const char *msg);
-    static bool hadException();
-    static KJSO exception();
-    static void clearException();
-
-    Context *context() const { return con; }
-    void setContext(Context *c) { con = c; }
-
-#ifdef KJS_DEBUGGER
-    /**
-     * Attach debugger d to this engine. If there already was another instance
-     * attached it will be detached.
-     */
-    void attachDebugger(Debugger *d);
+
+    ExecState *globalExec() { return globExec; }
+    bool checkSyntax(const UString &code);
+    Completion evaluate(const UString &code, const Value &thisV);
     Debugger *debugger() const { return dbg; }
-    int sourceId() const { return sid; }
-    bool setBreakpoint(int id, int line, bool set);
+    void setDebugger(Debugger *d);
+
+    Object builtinObject() const { return b_Object; }
+    Object builtinFunction() const { return b_Function; }
+    Object builtinArray() const { return b_Array; }
+    Object builtinBoolean() const { return b_Boolean; }
+    Object builtinString() const { return b_String; }
+    Object builtinNumber() const { return b_Number; }
+    Object builtinDate() const { return b_Date; }
+    Object builtinRegExp() const { return b_RegExp; }
+    Object builtinError() const { return b_Error; }
+
+    Object builtinObjectPrototype() const { return b_ObjectPrototype; }
+    Object builtinFunctionPrototype() const { return b_FunctionPrototype; }
+    Object builtinArrayPrototype() const { return b_ArrayPrototype; }
+    Object builtinBooleanPrototype() const { return b_BooleanPrototype; }
+    Object builtinStringPrototype() const { return b_StringPrototype; }
+    Object builtinNumberPrototype() const { return b_NumberPrototype; }
+    Object builtinDatePrototype() const { return b_DatePrototype; }
+    Object builtinRegExpPrototype() const { return b_RegExpPrototype; }
+    Object builtinErrorPrototype() const { return b_ErrorPrototype; }
+
+    Object builtinEvalError() const { return b_evalError; }
+    Object builtinRangeError() const { return b_rangeError; }
+    Object builtinReferenceError() const { return b_referenceError; }
+    Object builtinSyntaxError() const { return b_syntaxError; }
+    Object builtinTypeError() const { return b_typeError; }
+    Object builtinURIError() const { return b_uriError; }
+
+    Object builtinEvalErrorPrototype() const { return b_evalErrorPrototype; }
+    Object builtinRangeErrorPrototype() const { return b_rangeErrorPrototype; }
+    Object builtinReferenceErrorPrototype() const { return b_referenceErrorPrototype; }
+    Object builtinSyntaxErrorPrototype() const { return b_syntaxErrorPrototype; }
+    Object builtinTypeErrorPrototype() const { return b_typeErrorPrototype; }
+    Object builtinURIErrorPrototype() const { return b_uriErrorPrototype; }
+
+    void setCompatMode(Interpreter::CompatMode mode) { m_compatMode = mode; }
+    Interpreter::CompatMode compatMode() const { return m_compatMode; }
+
+    // Chained list of interpreters (ring)
+    static InterpreterImp* firstInterpreter() { return s_hook; }
+    InterpreterImp *nextInterpreter() const { return next; }
+    InterpreterImp *prevInterpreter() const { return prev; }
+
+  private:
+    void clear();
+    Interpreter *m_interpreter;
+    Object global;
+    Debugger *dbg;
+
+    // Built-in properties of the object prototype. These are accessible
+    // from here even if they are replaced by js code (e.g. assigning to
+    // Array.prototype)
+
+    Object b_Object;
+    Object b_Function;
+    Object b_Array;
+    Object b_Boolean;
+    Object b_String;
+    Object b_Number;
+    Object b_Date;
+    Object b_RegExp;
+    Object b_Error;
+
+    Object b_ObjectPrototype;
+    Object b_FunctionPrototype;
+    Object b_ArrayPrototype;
+    Object b_BooleanPrototype;
+    Object b_StringPrototype;
+    Object b_NumberPrototype;
+    Object b_DatePrototype;
+    Object b_RegExpPrototype;
+    Object b_ErrorPrototype;
+
+    Object b_evalError;
+    Object b_rangeError;
+    Object b_referenceError;
+    Object b_syntaxError;
+    Object b_typeError;
+    Object b_uriError;
+
+    Object b_evalErrorPrototype;
+    Object b_rangeErrorPrototype;
+    Object b_referenceErrorPrototype;
+    Object b_syntaxErrorPrototype;
+    Object b_typeErrorPrototype;
+    Object b_uriErrorPrototype;
+
+    ExecState *globExec;
+    Interpreter::CompatMode m_compatMode;
+
+    // Chained list of interpreters (ring) - for collector
+    static InterpreterImp* s_hook;
+    InterpreterImp *next, *prev;
+
+    int recursion;
+  };
+
+  class AttachedInterpreter;
+  class DebuggerImp {
+  public:
+
+    DebuggerImp() {
+      interps = 0;
+      isAborted = false;
+    }
+
+    void abort() { isAborted = true; }
+    bool aborted() const { return isAborted; }
+
+    AttachedInterpreter *interps;
+    bool isAborted;
+  };
+
+
+
+  class InternalFunctionImp : public ObjectImp {
+  public:
+    InternalFunctionImp(FunctionPrototypeImp *funcProto);
+    bool implementsHasInstance() const;
+    Boolean hasInstance(ExecState *exec, const Value &value);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  };
+
+  // helper function for toInteger, toInt32, toUInt32 and toUInt16
+  double roundValue(ExecState *exec, const Value &v);
+
+#ifndef NDEBUG
+  void printInfo(ExecState *exec, const char *s, const Value &o, int lineno = -1);
 #endif
-  private:
-    /**
-     * Initialize global object and context. For internal use only.
-     */
-    void init();
-    void clear();
-    /**
-     * Called when the first interpreter is instanciated. Initializes
-     * global pointers.
-     */
-    void globalInit();
-    /**
-     * Called when the last interpreter instance is destroyed. Frees
-     * globally allocated memory.
-     */
-    void globalClear();
-    bool evaluate(const UChar *code, unsigned int length, const KJSO &thisV = KJSO(),
-                  bool onlyCheckSyntax = false);
-    bool call(const KJSO &scope, const UString &func, const List &args);
-    bool call(const KJSO &func, const KJSO &thisV,
-              const List &args, const List &extraScope);
-
-  public:
-    ProgramNode *progNode() const { return stack->progNode; }
-    void setProgNode(ProgramNode *p) { stack->progNode = p; }
-    Node *firstNode() const { return stack->firstNode; }
-    void setFirstNode(Node *n) { stack->firstNode = n; }
-    void pushStack();
-    void popStack();
-    KJScriptImp *next, *prev;
-    KJScript *scr;
-    ExecutionStack *stack;
-
-  private:
-    ProgramNode *progN;
-    Node *firstN;
-
-    static KJScriptImp *curr, *hook;
-    static int instances; // total number of instances
-    static int running; // total number running
-    bool initialized;
-    Lexer *lex;
-    Context *con;
-    Global glob;
-    int errType, errLine;
-    UString errMsg;
-#ifdef KJS_DEBUGGER
-    Debugger *dbg;
-    int sid;
-#endif
-    const char *exMsg;
-    Imp *exVal;
-    Imp *retVal;
-    int recursion;
-  };
-
-  inline bool KJScriptImp::hadException()
-  {
-    assert(curr);
-    return curr->exMsg;
-  }
-
-  /**
-   * @short Struct used to return the property names of an object
-   */
-  class PropList {
-  public:
-    PropList(UString nm = UString::null, PropList *nx = 0) :
-                          name(nm), next(nx) {};
-    ~PropList() {
-      if(next) delete next;
-    }
-    /**
-     * The property name
-     */
-    UString name;
-    /**
-     * The next property
-     */
-    PropList *next;
-    bool contains(const UString &name);
-  };
-
-  /* TODO just temporary until functions are objects and this becomes
-     a member function. Called by RelationNode for 'instanceof' operator. */
-  KJSO hasInstance(const KJSO &F, const KJSO &V);
-
-// #define KJS_VERBOSE
-#ifndef NDEBUG
-  void printInfo( const char *s, const KJSO &o );
-#endif
 
 }; // namespace
 
 
-#endif
+#endif //  _INTERNAL_H_

trunk/JavaScriptCore/kjs/lexer.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
@@ -29 +32 @@
 #include <assert.h>
 
-#include "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "nodes.h"
 #include "lexer.h"
@@ -39 +45 @@
 using namespace KJS;
 
+static Lexer *currLexer = 0;
+
 #ifndef KDE_USE_FINAL
 #include "grammar.h"
@@ -45 +53 @@
 #include "lexer.lut.h"
 
-#ifdef KJS_DEBUGGER
 extern YYLTYPE yylloc;  // global bison variable holding token info
-#endif
 
 // a bridge for yacc from the C world to C++
@@ -58 +64 @@
   : yylineno(0),
     size8(128), size16(128), restrKeyword(false),
-    stackToken(-1), pos(0),
+    eatNextIdentifier(false), stackToken(-1), lastToken(-1), pos(0),
     code(0), length(0),
 #ifndef KJS_PURE_ECMA
@@ -68 +74 @@
   buffer8 = new char[size8];
   buffer16 = new UChar[size16];
+  currLexer = this;
 
 }
@@ -79 +86 @@
 Lexer *Lexer::curr()
 {
-  assert(KJScriptImp::current());
-  return KJScriptImp::current()->lex;
+  if (!currLexer) {
+    // create singleton instance
+    currLexer = new Lexer();
+  }
+  return currLexer;
 }
 
@@ -88 +98 @@
   restrKeyword = false;
   delimited = false;
+  eatNextIdentifier = false;
   stackToken = -1;
+  lastToken = -1;
   pos = 0;
   code = c;
   length = len;
+  skipLF = false;
+  skipCR = false;
 #ifndef KJS_PURE_ECMA
   bol = true;
@@ -128 +142 @@
   done = false;
   terminator = false;
+  skipLF = false;
+  skipCR = false;
 
   // did we push a token on the stack previously ?
@@ -138 +154 @@
 
   while (!done) {
+    if (skipLF && current != '\n') // found \r but not \n afterwards
+        skipLF = false;
+    if (skipCR && current != '\r') // found \n but not \r afterwards
+        skipCR = false;
+    if (skipLF || skipCR) // found \r\n or \n\r -> eat the second one
+    {
+        skipLF = false;
+        skipCR = false;
+        shift(1);
+    }
     switch (state) {
     case Start:
@@ -316 +342 @@
         record8(current);
         state = InOctal;
+      } else if (isDecimalDigit(current)) {
+        record8(current);
+        state = InDecimal;
       } else {
         setDone(Number);
@@ -330 +359 @@
       if (isOctalDigit(current)) {
         record8(current);
+      }
+      else if (isDecimalDigit(current)) {
+        record8(current);
+        state = InDecimal;
       } else
         setDone(Octal);
@@ -434 +467 @@
 #endif
 
+  if (state != Identifier && eatNextIdentifier)
+    eatNextIdentifier = false;
+
   restrKeyword = false;
   delimited = false;
-#ifdef KJS_DEBUGGER
   yylloc.first_line = yylineno; // ???
   yylloc.last_line = yylineno;
-#endif
 
   switch (state) {
   case Eof:
-    return 0;
+    token = 0;
+    break;
   case Other:
     if(token == '}' || token == ';') {
       delimited = true;
     }
-    return token;
+    break;
   case Identifier:
     if ((token = Lookup::find(&mainTable, buffer16, pos16)) < 0) {
+      // Lookup for keyword failed, means this is an identifier
+      // Apply anonymous-function hack below (eat the identifier)
+      if (eatNextIdentifier) {
+        eatNextIdentifier = false;
+        UString debugstr(buffer16, pos16); fprintf(stderr,"Anonymous function hack: eating identifier %s\n",debugstr.ascii());
+        token = lex();
+        break;
+      }
       /* TODO: close leak on parse error. same holds true for String */
       kjsyylval.ustr = new UString(buffer16, pos16);
-      return IDENT;
+      token = IDENT;
+      break;
     }
+
+    eatNextIdentifier = false;
+    // Hack for "f = function somename() { ... }", too hard to get into the grammar
+    if (token == FUNCTION && lastToken == '=' )
+      eatNextIdentifier = true;
+
     if (token == CONTINUE || token == BREAK ||
         token == RETURN || token == THROW)
       restrKeyword = true;
-    return token;
+    break;
   case String:
-    kjsyylval.ustr = new UString(buffer16, pos16); return STRING;
+    kjsyylval.ustr = new UString(buffer16, pos16);
+    token = STRING;
+    break;
   case Number:
     kjsyylval.dval = dval;
-    return NUMBER;
+    token = NUMBER;
+    break;
   case Bad:
     fprintf(stderr, "yylex: ERROR.\n");
@@ -471 +524 @@
     return -1;
   }
+  lastToken = token;
+  return token;
 }
 
@@ -479 +534 @@
 }
 
-bool Lexer::isLineTerminator() const
-{
-  return (current == '\n' || current == '\r');
+bool Lexer::isLineTerminator()
+{
+  bool cr = (current == '\r');
+  bool lf = (current == '\n');
+  if (cr)
+      skipLF = true;
+  else if (lf)
+      skipCR = true;
+  return cr || lf;
 }
 
@@ -541 +602 @@
   } else if (c1 == '+' && c2 == '+') {
     shift(2);
-    if (terminator) {
-      // automatic semicolon insertion
-      stackToken = PLUSPLUS;
-      return AUTO;
-    } else
+    if (terminator)
+      return AUTOPLUSPLUS;
+    else
       return PLUSPLUS;
   } else if (c1 == '-' && c2 == '-') {
     shift(2);
-    if (terminator) {
-      // automatic semicolon insertion
-      stackToken = MINUSMINUS;
-      return AUTO;
-    } else
+    if (terminator)
+      return AUTOMINUSMINUS;
+    else
       return MINUSMINUS;
   } else if (c1 == '=' && c2 == '=') {
@@ -716 +773 @@
   pos16 = 0;
   bool lastWasEscape = false;
+  bool inBrackets = false;
 
   while (1) {
     if (isLineTerminator() || current == 0)
       return false;
-    else if (current != '/' || lastWasEscape == true)
+    else if (current != '/' || lastWasEscape == true || inBrackets == true)
     {
+        // keep track of '[' and ']'
+        if ( !lastWasEscape ) {
+          if ( current == '[' && !inBrackets )
+            inBrackets = true;
+          if ( current == ']' && inBrackets )
+            inBrackets = false;
+        }
         record16(current);
         lastWasEscape =
             !lastWasEscape && (current == '\\');
     }
-    else {
+    else { // end of regexp
       pattern = UString(buffer16, pos16);
       pos16 = 0;

trunk/JavaScriptCore/kjs/lexer.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
@@ -64 +67 @@
                  Other,
                  Bad };
-    
+
     bool scanRegExp();
     UString pattern, flags;
@@ -79 +82 @@
     // encountered delimiter like "'" and "}" on last run
     bool delimited;
+    bool skipLF;
+    bool skipCR;
+    bool eatNextIdentifier;
     int stackToken;
+    int lastToken;
 
     State state;
@@ -88 +95 @@
 
     bool isWhiteSpace() const;
-    bool isLineTerminator() const;
+    bool isLineTerminator();
     bool isHexDigit(unsigned short c) const;
     bool isOctalDigit(unsigned short c) const;
@@ -120 +127 @@
     unsigned short current, next1, next2, next3;
 
-    struct keyword {
-      const char *name;
-      int token;
-    };
-
     // for future extensions
     class LexerPrivate;

trunk/JavaScriptCore/kjs/lexer.lut.h

@@ -1 @@
-/* automatically generated from keywords.table. DO NOT EDIT ! */
+/* Automatically generated from keywords.table using ./create_hash_table. DO NOT EDIT ! */
+
+#include "lookup.h"
 
 namespace KJS {
 
-const struct HashEntry2 mainTableEntries[] = {
-   { "instanceof", INSTANCEOF, 0, &mainTableEntries[63] },
-   { "var", VAR, 0, &mainTableEntries[47] },
-   { "case", CASE, 0, &mainTableEntries[41] },
-   { "default", DEFAULT, 0, &mainTableEntries[54] },
-   { "while", WHILE, 0, &mainTableEntries[46] },
-   { 0, 0, 0, 0 },
-   { "do", DO, 0, 0 },
-   { "typeof", TYPEOF, 0, 0 },
-   { "continue", CONTINUE, 0, 0 },
-   { "function", FUNCTION, 0, 0 },
-   { "in", IN, 0, 0 },
-   { "import", RESERVED, 0, 0 },
-   { "delete", DELETE, 0, 0 },
-   { "finally", FINALLY, 0, 0 },
-   { 0, 0, 0, 0 },
-   { "else", ELSE, 0, 0 },
-   { "return", RETURN, 0, 0 },
-   { "debugger", RESERVED, 0, 0 },
-   { "const", RESERVED, 0, &mainTableEntries[48] },
-   { "package", RESERVED, 0, 0 },
-   { "double", RESERVED, 0, &mainTableEntries[53] },
-   { 0, 0, 0, 0 },
-   { "long", RESERVED, 0, 0 },
-   { "catch", CATCH, 0, &mainTableEntries[45] },
-   { "void", VOID, 0, &mainTableEntries[59] },
-   { "break", BREAK, 0, &mainTableEntries[49] },
-   { "byte", RESERVED, 0, &mainTableEntries[62] },
-   { "enum", RESERVED, 0, &mainTableEntries[58] },
-   { 0, 0, 0, 0 },
-   { 0, 0, 0, 0 },
-   { "this", THIS, 0, &mainTableEntries[50] },
-   { "false", FALSETOKEN, 0, &mainTableEntries[44] },
-   { "abstract", RESERVED, 0, &mainTableEntries[56] },
-   { "null", NULLTOKEN, 0, &mainTableEntries[61] },
-   { "with", WITH, 0, 0 },
-   { 0, 0, 0, 0 },
-   { 0, 0, 0, 0 },
-   { 0, 0, 0, 0 },
-   { "true", TRUETOKEN, 0, 0 },
-   { "boolean", RESERVED, 0, 0 },
-   { "for", FOR, 0, 0 },
-   { "new", NEW, 0, &mainTableEntries[42] },
-   { "if", IF, 0, &mainTableEntries[43] },
-   { "switch", SWITCH, 0, &mainTableEntries[55] },
-   { "throw", THROW, 0, &mainTableEntries[52] },
-   { "try", TRY, 0, &mainTableEntries[64] },
-   { "char", RESERVED, 0, 0 },
-   { "class", RESERVED, 0, &mainTableEntries[51] },
-   { "export", RESERVED, 0, 0 },
-   { "extends", RESERVED, 0, &mainTableEntries[57] },
-   { "final", RESERVED, 0, 0 },
-   { "float", RESERVED, 0, 0 },
-   { "goto", RESERVED, 0, 0 },
-   { "implements", RESERVED, 0, 0 },
-   { "int", RESERVED, 0, &mainTableEntries[66] },
-   { "interface", RESERVED, 0, 0 },
-   { "native", RESERVED, 0, 0 },
-   { "private", RESERVED, 0, 0 },
-   { "protected", RESERVED, 0, &mainTableEntries[60] },
-   { "public", RESERVED, 0, 0 },
-   { "short", RESERVED, 0, 0 },
-   { "static", RESERVED, 0, 0 },
-   { "super", RESERVED, 0, 0 },
-   { "synchronized", RESERVED, 0, &mainTableEntries[65] },
-   { "throws", RESERVED, 0, 0 },
-   { "transient", RESERVED, 0, 0 },
-   { "volatile", RESERVED, 0, 0 }
+const struct HashEntry mainTableEntries[] = {
+   { "instanceof", INSTANCEOF, 0, 0, &mainTableEntries[63] },
+   { "var", VAR, 0, 0, &mainTableEntries[47] },
+   { "case", CASE, 0, 0, &mainTableEntries[41] },
+   { "default", DEFAULT, 0, 0, &mainTableEntries[54] },
+   { "while", WHILE, 0, 0, &mainTableEntries[46] },
+   { 0, 0, 0, 0, 0 },
+   { "do", DO, 0, 0, 0 },
+   { "typeof", TYPEOF, 0, 0, 0 },
+   { "continue", CONTINUE, 0, 0, 0 },
+   { "function", FUNCTION, 0, 0, 0 },
+   { "in", IN, 0, 0, 0 },
+   { "import", RESERVED, 0, 0, 0 },
+   { "delete", DELETE, 0, 0, 0 },
+   { "finally", FINALLY, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { "else", ELSE, 0, 0, 0 },
+   { "return", RETURN, 0, 0, 0 },
+   { "debugger", RESERVED, 0, 0, 0 },
+   { "const", RESERVED, 0, 0, &mainTableEntries[48] },
+   { "package", RESERVED, 0, 0, 0 },
+   { "double", RESERVED, 0, 0, &mainTableEntries[53] },
+   { 0, 0, 0, 0, 0 },
+   { "long", RESERVED, 0, 0, 0 },
+   { "catch", CATCH, 0, 0, &mainTableEntries[45] },
+   { "void", VOID, 0, 0, &mainTableEntries[59] },
+   { "break", BREAK, 0, 0, &mainTableEntries[49] },
+   { "byte", RESERVED, 0, 0, &mainTableEntries[62] },
+   { "enum", RESERVED, 0, 0, &mainTableEntries[58] },
+   { 0, 0, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { "this", THIS, 0, 0, &mainTableEntries[50] },
+   { "false", FALSETOKEN, 0, 0, &mainTableEntries[44] },
+   { "abstract", RESERVED, 0, 0, &mainTableEntries[56] },
+   { "null", NULLTOKEN, 0, 0, &mainTableEntries[61] },
+   { "with", WITH, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { "true", TRUETOKEN, 0, 0, 0 },
+   { "boolean", RESERVED, 0, 0, 0 },
+   { "for", FOR, 0, 0, 0 },
+   { "new", NEW, 0, 0, &mainTableEntries[42] },
+   { "if", IF, 0, 0, &mainTableEntries[43] },
+   { "switch", SWITCH, 0, 0, &mainTableEntries[55] },
+   { "throw", THROW, 0, 0, &mainTableEntries[52] },
+   { "try", TRY, 0, 0, &mainTableEntries[64] },
+   { "char", RESERVED, 0, 0, 0 },
+   { "class", RESERVED, 0, 0, &mainTableEntries[51] },
+   { "export", RESERVED, 0, 0, 0 },
+   { "extends", RESERVED, 0, 0, &mainTableEntries[57] },
+   { "final", RESERVED, 0, 0, 0 },
+   { "float", RESERVED, 0, 0, 0 },
+   { "goto", RESERVED, 0, 0, 0 },
+   { "implements", RESERVED, 0, 0, 0 },
+   { "int", RESERVED, 0, 0, &mainTableEntries[66] },
+   { "interface", RESERVED, 0, 0, 0 },
+   { "native", RESERVED, 0, 0, 0 },
+   { "private", RESERVED, 0, 0, 0 },
+   { "protected", RESERVED, 0, 0, &mainTableEntries[60] },
+   { "public", RESERVED, 0, 0, 0 },
+   { "short", RESERVED, 0, 0, 0 },
+   { "static", RESERVED, 0, 0, 0 },
+   { "super", RESERVED, 0, 0, 0 },
+   { "synchronized", RESERVED, 0, 0, &mainTableEntries[65] },
+   { "throws", RESERVED, 0, 0, 0 },
+   { "transient", RESERVED, 0, 0, 0 },
+   { "volatile", RESERVED, 0, 0, 0 }
 };
 
-const struct HashTable2 mainTable = { 2, 67, mainTableEntries, 41 };
+const struct HashTable mainTable = { 2, 67, mainTableEntries, 41 };
 
 }; // namespace

trunk/JavaScriptCore/kjs/lookup.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$
  */
 
@@ -29 +32 @@
 using namespace KJS;
 
-int Lookup::find(const struct HashTable *table,
-                 const UChar *c, unsigned int len)
-{
-  // we only know about version 1 so far
-  if (table->type != 1) {
-    fprintf(stderr, "Unknown hash table version.\n");
-    return -1;
-  }
-
-  int h = hash(c, len) % table->hashSize;
-  const HashEntry *e = &table->entries[h];
-
-  // empty bucket ?
-  if (!e->c)
-    return -1;
-
-  do {
-    // compare strings
-#ifdef KJS_SWAPPED_CHAR
-    /* TODO: not exactly as optimized as the other version ... */
-    if (len == e->len) {
-        const UChar *u = (const UChar*)e->c;
-        const UChar *c2 = c;
-        unsigned int i;
-        for (i = 0; i < len; i++, u++, c2++)
-            if (!(*c2 == UChar(u->low(), u->high()))) // reverse byte order
-                goto next;
-        return e->value;
-    }
-next:
-#else
-    if ((len == e->len) && (memcmp(c, e->c, len * sizeof(UChar)) == 0))
-        return e->value;
-#endif
-    // try next bucket
-    e = e->next;
-  } while (e);
-
-  return -1;
-}
-
-int Lookup::find(const struct HashTable *table, const UString &s)
-{
-  return find(table, s.data(), s.size());
-}
-
-int Lookup::find(const struct HashTable2 *table,
-                 const UChar *c, unsigned int len)
+const HashEntry* Lookup::findEntry( const struct HashTable *table,
+                              const UChar *c, unsigned int len )
 {
   if (table->type != 2) {
-    fprintf(stderr, "Unknown hash table version.\n");
-    return -1;
+    fprintf(stderr, "KJS: Unknown hash table version.\n");
+    return 0;
   }
-
   char *ascii = new char[len+1];
   unsigned int i;
@@ -94 +50 @@
 
   int h = hash(ascii) % table->hashSize;
-  const HashEntry2 *e = &table->entries[h];
+  const HashEntry *e = &table->entries[h];
 
   // empty bucket ?
   if (!e->s) {
     delete [] ascii;
-    return -1;
+    return 0;
   }
 
@@ -106 +62 @@
     if (strcmp(ascii, e->s) == 0) {
       delete [] ascii;
-      return e->value;
+      return e;
     }
     // try next bucket
@@ -113 +69 @@
 
   delete [] ascii;
+  return 0;
+}
+
+const HashEntry* Lookup::findEntry( const struct HashTable *table,
+                                const UString &s )
+{
+  return findEntry( table, s.data(), s.size() );
+}
+
+int Lookup::find(const struct HashTable *table,
+                 const UChar *c, unsigned int len)
+{
+  const HashEntry *entry = findEntry( table, c, len );
+  if (entry)
+    return entry->value;
   return -1;
 }
 
-int Lookup::find(const struct HashTable2 *table, const UString &s)
+int Lookup::find(const struct HashTable *table, const UString &s)
 {
   return find(table, s.data(), s.size());

trunk/JavaScriptCore/kjs/lookup.h

@@ +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$
  */
 
@@ -22 +25 @@
 
 #include "ustring.h"
+#include "value.h"
+#include <stdio.h>
 
 namespace KJS {
 
-#if 1  // obsolete version 1
+  /**
+   * An entry in a hash table.
+   */
   struct HashEntry {
-    unsigned int len;
-    const void *c; // unicode data
+    /** s is the key (e.g. a property name) */
+    const char *s;
+    /** value is the result value (usually an enum value) */
     int value;
+    /** attr is a set for flags (e.g. the property flags, see object.h) */
+    short int attr;
+    /** params is another number. For property hashtables, it is used to
+        denote the number of argument of the function */
+    short int params;
+    /** next is the pointer to the next entry for the same hash value */
     const HashEntry *next;
   };
 
+  /**
+   * A hash table
+   * Usually the hashtable is generated by the create_hash_table script, from a .table file.
+   *
+   * The implementation uses an array of entries, "size" is the total size of that array.
+   * The entries between 0 and hashSize-1 are the entry points
+   * for each hash value, and the entries between hashSize and size-1
+   * are the overflow entries for the hash values that need one.
+   * The "next" pointer of the entry links entry points to overflow entries,
+   * and links overflow entries between them.
+   */
   struct HashTable {
+    /** type is a version number. Currently always 2 */
     int type;
+    /** size is the total number of entries in the hashtable, including the null entries,
+     * i.e. the size of the "entries" array.
+     * Used to iterate over all entries in the table */
     int size;
+    /** pointer to the array of entries
+     * Mind that some entries in the array are null (0,0,0,0). */
     const HashEntry *entries;
-    int hashSize;
-  };
-#endif
-
-  // version 2
-  struct HashEntry2 {
-    const char *s;
-    int value;
-    int attr;
-    const HashEntry2 *next;
-  };
-
-  struct HashTable2 {
-    int type;
-    int size;
-    const HashEntry2 *entries;
+    /** the maximum value for the hash. Always smaller than size. */
     int hashSize;
   };
@@ -61 +77 @@
   class Lookup {
   public:
-#if 1 // obsolete
+    /** Find an entry in the table, and return its value (i.e. the value field of HashEntry) */
     static int find(const struct HashTable *table, const UString &s);
     static int find(const struct HashTable *table,
                     const UChar *c, unsigned int len);
+
+    /**
+     * Find an entry in the table, and return the entry
+     * This variant gives access to the other attributes of the entry,
+     * especially the attr field.
+     */
+    static const HashEntry* findEntry(const struct HashTable *table,
+                                      const UString &s);
+    static const HashEntry* findEntry(const struct HashTable *table,
+                                      const UChar *c, unsigned int len);
+
+    /** Calculate the hash value for a given key */
+    static unsigned int hash(const UString &key);
+    static unsigned int hash(const UChar *c, unsigned int len);
+    static unsigned int hash(const char *s);
+  };
+
+  class ExecState;
+  class UString;
+  /** @internal
+   * Helper for lookupFunction and lookupValueOrFunction */
+  template <class FuncImp>
+  inline Value lookupOrCreateFunction(ExecState *exec, const UString &propertyName,
+                                      const ObjectImp *thisObj, int token, int params, int attr)
+  {
+      // Look for cached value in dynamic map of properties (in ObjectImp)
+      ValueImp * cachedVal = thisObj->ObjectImp::getDirect(propertyName);
+      /*if (cachedVal)
+        fprintf(stderr, "lookupOrCreateFunction: Function -> looked up in ObjectImp, found type=%d\n", cachedVal->type());*/
+      if (cachedVal)
+        return Value(cachedVal);
+
+      Value val = Value(new FuncImp(exec,token, params));
+      ObjectImp *thatObj = const_cast<ObjectImp *>(thisObj);
+      thatObj->ObjectImp::put(exec, propertyName, val, attr);
+      return val;
+  }
+
+  /**
+   * Helper method for property lookups
+   *
+   * This method does it all (looking in the hashtable, checking for function
+   * overrides, creating the function or retrieving from cache, calling
+   * getValueProperty in case of a non-function property, forwarding to parent if
+   * unknown property).
+   *
+   * Template arguments:
+   * @param FuncImp the class which implements this object's functions
+   * @param ThisImp the class of "this". It must implement the getValueProperty(exec,token) method,
+   * for non-function properties.
+   * @param ParentImp the class of the parent, to propagate the lookup.
+   *
+   * Method arguments:
+   * @param exec execution state, as usual
+   * @param propertyName the property we're looking for
+   * @param table the static hashtable for this class
+   * @param thisObj "this"
+   */
+  template <class FuncImp, class ThisImp, class ParentImp>
+  inline Value lookupGet(ExecState *exec, const UString &propertyName,
+                         const HashTable* table, const ThisImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found, forward to parent
+      return thisObj->ParentImp::get(exec, propertyName);
+
+    //fprintf(stderr, "lookupGet: found value=%d attr=%d\n", entry->value, entry->attr);
+    if (entry->attr & Function)
+      return lookupOrCreateFunction<FuncImp>(exec, propertyName, thisObj, entry->value, entry->params, entry->attr);
+    return thisObj->getValueProperty(exec, entry->value);
+  }
+
+  /**
+   * Simplified version of lookupGet in case there are only functions.
+   * Using this instead of lookupGet prevents 'this' from implementing a dummy getValueProperty.
+   */
+  template <class FuncImp, class ParentImp>
+  inline Value lookupGetFunction(ExecState *exec, const UString &propertyName,
+                         const HashTable* table, const ObjectImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found, forward to parent
+      return static_cast<const ParentImp *>(thisObj)->ParentImp::get(exec, propertyName);
+
+    if (entry->attr & Function)
+      return lookupOrCreateFunction<FuncImp>(exec, propertyName, thisObj, entry->value, entry->params, entry->attr);
+
+    fprintf(stderr, "Function bit not set! Shouldn't happen in lookupGetFunction!\n" );
+    return Undefined();
+  };
+
+  /**
+   * Simplified version of lookupGet in case there are no functions, only "values".
+   * Using this instead of lookupGet removes the need for a FuncImp class.
+   */
+  template <class ThisImp, class ParentImp>
+  inline Value lookupGetValue(ExecState *exec, const UString &propertyName,
+                           const HashTable* table, const ThisImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found, forward to parent
+      return thisObj->ParentImp::get(exec, propertyName);
+
+    if (entry->attr & Function)
+      fprintf(stderr, "Function bit set! Shouldn't happen in lookupGetValue! propertyName was %s\n", propertyName.ascii() );
+    return thisObj->getValueProperty(exec, entry->value);
+  }
+
+  /**
+   * This one is for "put".
+   * Lookup hash entry for property to be set, and set the value.
+   */
+  template <class ThisImp, class ParentImp>
+  inline void lookupPut(ExecState *exec, const UString &propertyName,
+                        const Value& value, int attr,
+                        const HashTable* table, const ThisImp* thisObj)
+  {
+    const HashEntry* entry = Lookup::findEntry(table, propertyName);
+
+    if (!entry) // not found: forward to parent
+      thisObj->ParentImp::put(exec, propertyName, value, attr);
+    else if (entry->attr & Function) // function: put as override property
+      thisObj->ObjectImp::put(exec, propertyName, value, attr);
+    else if (entry->attr & ReadOnly) // readonly! Can't put!
+#ifdef KJS_VERBOSE
+      fprintf(stderr,"WARNING: Attempt to change value of readonly property '%s'\n",propertyName.ascii());
+#else
+      ; // do nothing
 #endif
-    static int find(const struct HashTable2 *table, const UString &s);
-    static int find(const struct HashTable2 *table,
-                    const UChar *c, unsigned int len);
-    static unsigned int hash(const UChar *c, unsigned int len);
-    static unsigned int hash(const UString &key);
-    static unsigned int hash(const char *s);
-  private:
-    HashTable *table;
-  };
-
+    else
+      thisObj->putValueProperty(exec, entry->value, value, attr);
+  }
+
+  /*
+   * List of things to do when porting an objectimp to the 'static hashtable' mechanism:
+   * - write the hashtable source, between @begin and @end
+   * - add a rule to build the .lut.h
+   * - include the .lut.h
+   * - mention the table in the classinfo (add a classinfo if necessary)
+   * - write/update the class enum (for the tokens)
+   * - turn get() into getValueProperty(), put() into putValueProperty(), using a switch and removing funcs
+   * - write get() and/or put() using a template method
+   * - cleanup old stuff (e.g. hasProperty)
+   * - compile, test, commit ;)
+   */
 }; // namespace
 

trunk/JavaScriptCore/kjs/math_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 <math.h>
 #include <stdlib.h>
-
-#include "kjs.h"
+#include <stdio.h>
+#include <assert.h>
+
+#include "value.h"
+#include "object.h"
 #include "types.h"
+#include "interpreter.h"
 #include "operations.h"
 #include "math_object.h"
-#include "lookup.h"
 
 #include "math_object.lut.h"
@@ -31 +37 @@
 using namespace KJS;
 
-KJSO Math::get(const UString &p) const
-{
-  int token = Lookup::find(&mathTable, p);
-
-  if (token < 0)
-    return Imp::get(p);
-
-  double d;
-  int len = 1;
+// ------------------------------ MathObjectImp --------------------------------
+
+const ClassInfo MathObjectImp::info = { "Math", 0, &mathTable, 0 };
+
+/* Source for math_object.lut.h
+@begin mathTable 21
+  E             MathObjectImp::Euler    DontEnum
+  LN2           MathObjectImp::Ln2      DontEnum
+  LN10          MathObjectImp::Ln10     DontEnum
+  LOG2E         MathObjectImp::Log2E    DontEnum
+  LOG10E        MathObjectImp::Log10E   DontEnum
+  PI            MathObjectImp::Pi       DontEnum
+  SQRT1_2       MathObjectImp::Sqrt1_2  DontEnum
+  SQRT2         MathObjectImp::Sqrt2    DontEnum
+  abs           MathObjectImp::Abs      DontEnum|Function 1
+  acos          MathObjectImp::ACos     DontEnum|Function 1
+  asin          MathObjectImp::ASin     DontEnum|Function 1
+  atan          MathObjectImp::ATan     DontEnum|Function 1
+  atan2         MathObjectImp::ATan2    DontEnum|Function 2
+  ceil          MathObjectImp::Ceil     DontEnum|Function 1
+  cos           MathObjectImp::Cos      DontEnum|Function 1
+  exp           MathObjectImp::Exp      DontEnum|Function 1
+  floor         MathObjectImp::Floor    DontEnum|Function 1
+  log           MathObjectImp::Log      DontEnum|Function 1
+  max           MathObjectImp::Max      DontEnum|Function 2
+  min           MathObjectImp::Min      DontEnum|Function 2
+  pow           MathObjectImp::Pow      DontEnum|Function 2
+  random        MathObjectImp::Random   DontEnum|Function 0
+  round         MathObjectImp::Round    DontEnum|Function 1
+  sin           MathObjectImp::Sin      DontEnum|Function 1
+  sqrt          MathObjectImp::Sqrt     DontEnum|Function 1
+  tan           MathObjectImp::Tan      DontEnum|Function 1
+@end
+*/
+
+MathObjectImp::MathObjectImp(ExecState * /*exec*/,
+                             ObjectPrototypeImp *objProto)
+  : ObjectImp(Object(objProto))
+{
+}
+
+// ECMA 15.8
+Value MathObjectImp::get(ExecState *exec, const UString &propertyName) const
+{
+  return lookupGet<MathFuncImp, MathObjectImp, ObjectImp>( exec, propertyName, &mathTable, this );
+}
+
+Value MathObjectImp::getValueProperty(ExecState *, int token) const
+{
+  double d = -42; // ;)
   switch (token) {
-  case Math::Euler:
+  case Euler:
     d = exp(1.0);
     break;
-  case Math::Ln2:
+  case Ln2:
     d = log(2.0);
     break;
-  case Math::Ln10:
+  case Ln10:
     d = log(10.0);
     break;
-  case Math::Log2E:
+  case Log2E:
     d = 1.0/log(2.0);
     break;
-  case Math::Log10E:
+  case Log10E:
     d = 1.0/log(10.0);
     break;
-  case Math::Pi:
+  case Pi:
     d = 2.0 * asin(1.0);
     break;
-  case Math::Sqrt1_2:
+  case Sqrt1_2:
     d = sqrt(0.5);
     break;
-  case Math::Sqrt2:
+  case Sqrt2:
     d = sqrt(2.0);
     break;
   default:
-    if (token == Math::Min || token == Math::Max || token == Math::Pow)
-      len = 2;
-    return Function(new MathFunc(token, len));
-  };
+    fprintf( stderr, "Internal error in MathObjectImp: unhandled token %d\n", token );
+    break;
+  }
 
   return Number(d);
 }
 
-bool Math::hasProperty(const UString &p, bool recursive) const
-{
-  return (Lookup::find(&mathTable, p) >= 0 ||
-          (recursive && Imp::hasProperty(p, recursive)));
-}
-
-Completion MathFunc::execute(const List &args)
-{
-  KJSO v = args[0];
-  Number n = v.toNumber();
+// ------------------------------ MathObjectImp --------------------------------
+
+MathFuncImp::MathFuncImp(ExecState *exec, int i, int l)
+  : InternalFunctionImp(
+    static_cast<FunctionPrototypeImp*>(exec->interpreter()->builtinFunctionPrototype().imp())
+    ), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(l),DontDelete|ReadOnly|DontEnum);
+}
+
+bool MathFuncImp::implementsCall() const
+{
+  return true;
+}
+
+Value MathFuncImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  Value v = args[0];
+  Number n = v.toNumber(exec);
   double arg = n.value();
 
-  KJSO v2 = args[1];
-  Number n2 = v2.toNumber();
+  Value v2 = args[1];
+  Number n2 = v2.toNumber(exec);
   double arg2 = n2.value();
   double result;
 
   switch (id) {
-  case Math::Abs:
-    result = ( arg < 0 ) ? (-arg) : arg;
-    break;
-  case Math::ACos:
+  case MathObjectImp::Abs:
+    result = ( arg < 0 || arg == -0) ? (-arg) : arg;
+    break;
+  case MathObjectImp::ACos:
     result = ::acos(arg);
     break;
-  case Math::ASin:
+  case MathObjectImp::ASin:
     result = ::asin(arg);
     break;
-  case Math::ATan:
+  case MathObjectImp::ATan:
     result = ::atan(arg);
     break;
-  case Math::ATan2:
+  case MathObjectImp::ATan2:
     result = ::atan2(arg, arg2);
     break;
-  case Math::Ceil:
+  case MathObjectImp::Ceil:
     result = ::ceil(arg);
     break;
-  case Math::Cos:
+  case MathObjectImp::Cos:
     result = ::cos(arg);
     break;
-  case Math::Exp:
+  case MathObjectImp::Exp:
     result = ::exp(arg);
     break;
-  case Math::Floor:
+  case MathObjectImp::Floor:
     result = ::floor(arg);
     break;
-  case Math::Log:
+  case MathObjectImp::Log:
     result = ::log(arg);
     break;
-  case Math::Max:
-    result = ( arg > arg2 ) ? arg : arg2;
-    break;
-  case Math::Min:
-    result = ( arg < arg2 ) ? arg : arg2;
-    break;
-  case Math::Pow:
-    result = ::pow(arg, arg2);
-    break;
-  case Math::Random:
+  case MathObjectImp::Max: {
+    unsigned int argsCount = args.size();
+    result = -Inf;
+    for ( unsigned int k = 0 ; k < argsCount ; ++k ) {
+      double val = args[k].toNumber(exec);
+      if ( isNaN( val ) )
+      {
+        result = NaN;
+        break;
+      }
+      if ( val > result )
+        result = val;
+    }
+    break;
+  }
+  case MathObjectImp::Min: {
+    unsigned int argsCount = args.size();
+    result = +Inf;
+    for ( unsigned int k = 0 ; k < argsCount ; ++k ) {
+      double val = args[k].toNumber(exec);
+      if ( isNaN( val ) )
+      {
+        result = NaN;
+        break;
+      }
+      if ( val < result )
+        result = val;
+    }
+    break;
+  }
+  case MathObjectImp::Pow:
+    // ECMA 15.8.2.1.13 (::pow takes care of most of the critera)
+    if (KJS::isNaN(arg2))
+      result = NaN;
+    else if (arg2 == 0)
+      result = 1;
+    else if (KJS::isNaN(arg) && arg2 != 0)
+      result = NaN;
+    else if (::fabs(arg) > 1 && KJS::isPosInf(arg2))
+      result = Inf;
+    else if (::fabs(arg) > 1 && KJS::isNegInf(arg2))
+      result = +0;
+    else if (::fabs(arg) == 1 && KJS::isPosInf(arg2))
+      result = NaN;
+    else if (::fabs(arg) == 1 && KJS::isNegInf(arg2))
+      result = NaN;
+    else if (::fabs(arg) < 1 && KJS::isPosInf(arg2))
+      result = +0;
+    else if (::fabs(arg) < 1 && KJS::isNegInf(arg2))
+      result = Inf;
+    else
+      result = ::pow(arg, arg2);
+    break;
+  case MathObjectImp::Random:
     result = ::rand();
     result = result / RAND_MAX;
     break;
-  case Math::Round:
+  case MathObjectImp::Round:
     if (isNaN(arg))
       result = arg;
@@ -145 +245 @@
       result = (double)(arg >= 0.0 ? int(arg + 0.5) : int(arg - 0.5));
     break;
-  case Math::Sin:
+  case MathObjectImp::Sin:
     result = ::sin(arg);
     break;
-  case Math::Sqrt:
+  case MathObjectImp::Sqrt:
     result = ::sqrt(arg);
     break;
-  case Math::Tan:
+  case MathObjectImp::Tan:
     result = ::tan(arg);
     break;
@@ -160 +260 @@
   }
 
-  return Completion(ReturnValue, Number(result));
-}
+  return Number(result);
+}

trunk/JavaScriptCore/kjs/math_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _MATH_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class Math : public ObjectImp {
+  class MathObjectImp : public ObjectImp {
   public:
-    Math() : ObjectImp(BooleanClass) { }
-    virtual KJSO get(const UString &p) const;
-    virtual bool hasProperty(const UString &p, bool recursive = true) const;
+    MathObjectImp(ExecState *exec,
+                  ObjectPrototypeImp *objProto);
+    Value get(ExecState *exec, const UString &p) const;
+    Value getValueProperty(ExecState *exec, int token) const;
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
     enum { Euler, Ln2, Ln10, Log2E, Log10E, Pi, Sqrt1_2, Sqrt2,
-           Abs, ACos, ASin, ATan, ATan2, Ceil, Cos, Pow,
-           Exp, Floor, Log, Max, Min, Random, Round, Sin, Sqrt, Tan };
+           Abs, ACos, ASin, ATan, ATan2, Ceil, Cos, Pow,
+           Exp, Floor, Log, Max, Min, Random, Round, Sin, Sqrt, Tan };
   };
 
-  class MathFunc : public InternalFunctionImp {
+  class MathFuncImp : public InternalFunctionImp {
   public:
-    MathFunc(int i, int l) : InternalFunctionImp(l), id(i) { }
-    Completion execute(const List &);
+    MathFuncImp(ExecState *exec, int i, int l);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
   private:
     int id;

trunk/JavaScriptCore/kjs/math_object.lut.h

@@ -1 @@
-/* automatically generated from math.table. DO NOT EDIT ! */
+/* Automatically generated from math_object.cpp using ./create_hash_table. DO NOT EDIT ! */
+
+#include "lookup.h"
 
 namespace KJS {
 
-const struct HashEntry2 mathTableEntries[] = {
-   { "atan", Math::ATan, DontEnum|ReadOnly, &mathTableEntries[25] },
-   { 0, 0, 0, 0 },
-   { "SQRT2", Math::Sqrt2, DontEnum|ReadOnly, &mathTableEntries[23] },
-   { 0, 0, 0, 0 },
-   { 0, 0, 0, 0 },
-   { 0, 0, 0, 0 },
-   { "E", Math::Euler, DontEnum|ReadOnly, &mathTableEntries[21] },
-   { "asin", Math::ASin, DontEnum|ReadOnly, &mathTableEntries[26] },
-   { "atan2", Math::ATan2, DontEnum|ReadOnly, &mathTableEntries[31] },
-   { "LOG2E", Math::Log2E, DontEnum|ReadOnly, &mathTableEntries[27] },
-   { "cos", Math::Cos, DontEnum|ReadOnly, 0 },
-   { "max", Math::Max, DontEnum|ReadOnly, &mathTableEntries[28] },
-   { 0, 0, 0, 0 },
-   { 0, 0, 0, 0 },
-   { "LOG10E", Math::Log10E, DontEnum|ReadOnly, &mathTableEntries[24] },
-   { "LN2", Math::Ln2, DontEnum|ReadOnly, &mathTableEntries[30] },
-   { "abs", Math::Abs, DontEnum|ReadOnly, 0 },
-   { "sqrt", Math::Sqrt, DontEnum|ReadOnly, 0 },
-   { "exp", Math::Exp, DontEnum|ReadOnly, 0 },
-   { 0, 0, 0, 0 },
-   { "LN10", Math::Ln10, DontEnum|ReadOnly, &mathTableEntries[22] },
-   { "PI", Math::Pi, DontEnum|ReadOnly, &mathTableEntries[29] },
-   { "SQRT1_2", Math::Sqrt1_2, DontEnum|ReadOnly, 0 },
-   { "acos", Math::ACos, DontEnum|ReadOnly, 0 },
-   { "ceil", Math::Ceil, DontEnum|ReadOnly, 0 },
-   { "floor", Math::Floor, DontEnum|ReadOnly, 0 },
-   { "log", Math::Log, DontEnum|ReadOnly, 0 },
-   { "min", Math::Min, DontEnum|ReadOnly, 0 },
-   { "random", Math::Random, DontEnum|ReadOnly, 0 },
-   { "round", Math::Round, DontEnum|ReadOnly, 0 },
-   { "sin", Math::Sin, DontEnum|ReadOnly, 0 },
-   { "tan", Math::Tan, DontEnum|ReadOnly, 0 }
+const struct HashEntry mathTableEntries[] = {
+   { "atan", MathObjectImp::ATan, DontEnum|Function, 1, &mathTableEntries[25] },
+   { 0, 0, 0, 0, 0 },
+   { "SQRT2", MathObjectImp::Sqrt2, DontEnum, 0, &mathTableEntries[23] },
+   { 0, 0, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { "E", MathObjectImp::Euler, DontEnum, 0, &mathTableEntries[21] },
+   { "asin", MathObjectImp::ASin, DontEnum|Function, 1, &mathTableEntries[26] },
+   { "atan2", MathObjectImp::ATan2, DontEnum|Function, 2, &mathTableEntries[32] },
+   { "LOG2E", MathObjectImp::Log2E, DontEnum, 0, &mathTableEntries[27] },
+   { "cos", MathObjectImp::Cos, DontEnum|Function, 1, 0 },
+   { "max", MathObjectImp::Max, DontEnum|Function, 2, &mathTableEntries[29] },
+   { 0, 0, 0, 0, 0 },
+   { 0, 0, 0, 0, 0 },
+   { "LOG10E", MathObjectImp::Log10E, DontEnum, 0, &mathTableEntries[24] },
+   { "LN2", MathObjectImp::Ln2, DontEnum, 0, &mathTableEntries[31] },
+   { "abs", MathObjectImp::Abs, DontEnum|Function, 1, 0 },
+   { "sqrt", MathObjectImp::Sqrt, DontEnum|Function, 1, 0 },
+   { "exp", MathObjectImp::Exp, DontEnum|Function, 1, 0 },
+   { 0, 0, 0, 0, 0 },
+   { "LN10", MathObjectImp::Ln10, DontEnum, 0, &mathTableEntries[22] },
+   { "PI", MathObjectImp::Pi, DontEnum, 0, &mathTableEntries[28] },
+   { "SQRT1_2", MathObjectImp::Sqrt1_2, DontEnum, 0, 0 },
+   { "acos", MathObjectImp::ACos, DontEnum|Function, 1, 0 },
+   { "ceil", MathObjectImp::Ceil, DontEnum|Function, 1, 0 },
+   { "floor", MathObjectImp::Floor, DontEnum|Function, 1, 0 },
+   { "log", MathObjectImp::Log, DontEnum|Function, 1, 0 },
+   { "min", MathObjectImp::Min, DontEnum|Function, 2, 0 },
+   { "pow", MathObjectImp::Pow, DontEnum|Function, 2, &mathTableEntries[30] },
+   { "random", MathObjectImp::Random, DontEnum|Function, 0, 0 },
+   { "round", MathObjectImp::Round, DontEnum|Function, 1, 0 },
+   { "sin", MathObjectImp::Sin, DontEnum|Function, 1, 0 },
+   { "tan", MathObjectImp::Tan, DontEnum|Function, 1, 0 }
 };
 
-const struct HashTable2 mathTable = { 2, 32, mathTableEntries, 21 };
+const struct HashTable mathTable = { 2, 33, mathTableEntries, 21 };
 
 }; // namespace

trunk/JavaScriptCore/kjs/nodes.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
  */
 
@@ -22 +25 @@
 
 #include <assert.h>
+#include <iostream.h>
+#include <math.h>
 #include <stdio.h>
-#include <math.h>
-
-#include "kjs.h"
+#ifdef KJS_DEBUG_MEM
+#include <typeinfo>
+#endif
+
+#include "collector.h"
+#include "debugger.h"
+#include "function_object.h"
+#include "internal.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
+#include "lexer.h"
+#include "operations.h"
 #include "ustring.h"
-#include "lexer.h"
-#include "types.h"
-#include "internal.h"
-#include "operations.h"
-#include "regexp_object.h"
-#include "debugger.h"
 
 using namespace KJS;
 
-#ifdef KJS_DEBUGGER
-#define KJS_BREAKPOINT if (!hitStatement()) return Completion(Normal);
-#define KJS_ABORTPOINT if (abortStatement()) return Completion(Normal);
-#else
-#define KJS_BREAKPOINT
-#define KJS_ABORTPOINT
+#define KJS_BREAKPOINT \
+  if (!hitStatement(exec)) \
+    return Completion(Normal);
+
+#define KJS_ABORTPOINT \
+  if (exec->interpreter()->imp()->debugger() && \
+      exec->interpreter()->imp()->debugger()->imp()->aborted()) \
+    return Completion(Normal);
+
+#define KJS_CHECKEXCEPTION \
+  if (exec->hadException()) \
+    return Completion(Throw, exec->exception()); \
+  if (Collector::outOfMemory()) \
+    return Completion(Throw, Error::create(exec,GeneralError,"Out of memory"));
+
+#define KJS_CHECKEXCEPTIONVALUE \
+  if (exec->hadException()) \
+    return exec->exception(); \
+  if (Collector::outOfMemory()) \
+    return Undefined(); // will be picked up by KJS_CHECKEXCEPTION
+
+#define KJS_CHECKEXCEPTIONLIST \
+  if (exec->hadException()) \
+    return List(); \
+  if (Collector::outOfMemory()) \
+    return List(); // will be picked up by KJS_CHECKEXCEPTION
+
+#ifdef KJS_DEBUG_MEM
+std::list<Node *> Node::s_nodes;
 #endif
-
-int   Node::nodeCount = 0;
-Node* Node::first = 0;
+// ------------------------------ Node -----------------------------------------
 
 Node::Node()
 {
-  assert(Lexer::curr());
   line = Lexer::curr()->lineNo();
-  nodeCount++;
-  //  cout << "Node()" << endl;
-
-  // create a list of allocated objects. Makes
-  // deleting (even after a parse error) quite easy
-  next = first;
-  prev = 0L;
-  if (first)
-    first->prev = this;
-  first = this;
+  refcount = 0;
+#ifdef KJS_DEBUG_MEM
+  s_nodes.push_back( this );
+#endif
 }
 
 Node::~Node()
 {
-  //  cout << "~Node()" << endl;
-  if (next)
-    next->prev = prev;
-  if (prev)
-    prev->next = next;
-  nodeCount--;
-}
-
-void Node::deleteAllNodes()
-{
-  Node *tmp, *n = first;
-
-  while ((tmp = n)) {
-    n = n->next;
-    delete tmp;
-  }
-  first = 0L;
-  //  assert(nodeCount == 0);
-}
-
-KJSO Node::throwError(ErrorType e, const char *msg)
-{
-  return Error::create(e, msg, lineNo());
-}
-
-#ifdef KJS_DEBUGGER
-void StatementNode::setLoc(int line0, int line1)
+#ifdef KJS_DEBUG_MEM
+  s_nodes.remove( this );
+#endif
+}
+
+#ifdef KJS_DEBUG_MEM
+void Node::finalCheck()
+{
+  fprintf( stderr, "Node::finalCheck(): list count       : %d\n", s_nodes.size() );
+  std::list<Node *>::iterator it = s_nodes.begin();
+  for ( uint i = 0; it != s_nodes.end() ; ++it, ++i )
+    fprintf( stderr, "[%d] Still having node %p (%s) (refcount %d)\n", i, (void*)*it, typeid( **it ).name(), (*it)->refcount );
+}
+#endif
+
+Value Node::throwError(ExecState *exec, ErrorType e, const char *msg)
+{
+  Object err = Error::create(exec, e, msg, lineNo(), sourceId());
+  exec->setException(err);
+  return err;
+}
+
+// ------------------------------ StatementNode --------------------------------
+StatementNode::StatementNode() : l0(-1), l1(-1), sid(-1), breakPoint(false)
+{
+}
+
+StatementNode::~StatementNode()
+{
+}
+
+void StatementNode::setLoc(int line0, int line1, int sourceId)
 {
     l0 = line0;
     l1 = line1;
-    sid = KJScriptImp::current()->sourceId();
-}
-
-bool StatementNode::hitStatement()
-{
-  if (KJScriptImp::current()->debugger())
-    return KJScriptImp::current()->debugger()->hit(firstLine(), breakPoint);
+    sid = sourceId;
+}
+
+// return true if the debugger wants us to stop at this point
+bool StatementNode::hitStatement(ExecState *exec)
+{
+  Debugger *dbg = exec->interpreter()->imp()->debugger();
+  if (dbg)
+    return dbg->atStatement(exec,sid,l0,l1);
   else
-    return true;
+    return true; // continue
 }
 
 // return true if the debugger wants us to stop at this point
-bool StatementNode::abortStatement()
-{
-  if (KJScriptImp::current()->debugger() &&
-      KJScriptImp::current()->debugger()->mode() == Debugger::Stop)
-      return true;
-
-  return false;
-}
-
-bool Node::setBreakpoint(Node *firstNode, int id, int line, bool set)
-{
-  while (firstNode) {
-    if (firstNode->setBreakpoint(id, line, set) && line >= 0) // line<0 for all
-      return true;
-    firstNode = firstNode->next;
-  }
-  return false;
-}
-
-/**
- * Try to set or delete a breakpoint depending on the value of set.
- * The call will return true if successful, i.e. if line is inside
- * of the statement's range. Additionally, a breakpoint had to
- * be set already if you tried to delete with set=false.
- */
-bool StatementNode::setBreakpoint(int id, int line, bool set)
-{
-  // in our source unit and line range ?
-  if (id != sid || ((line < l0 || line > l1) && line >= 0))
+bool StatementNode::abortStatement(ExecState *exec)
+{
+  Debugger *dbg = exec->interpreter()->imp()->debugger();
+  if (dbg)
+    return dbg->imp()->aborted();
+  else
     return false;
-
-  if (!set && !breakPoint)
-    return false;
-
-  breakPoint = set;
-  return true;
-}
-#endif
-
-KJSO NullNode::evaluate()
+}
+
+// ------------------------------ NullNode -------------------------------------
+
+Value NullNode::evaluate(ExecState */*exec*/)
 {
   return Null();
 }
 
-KJSO BooleanNode::evaluate()
+// ------------------------------ BooleanNode ----------------------------------
+
+Value BooleanNode::evaluate(ExecState */*exec*/)
 {
   return Boolean(value);
 }
 
-KJSO NumberNode::evaluate()
+// ------------------------------ NumberNode -----------------------------------
+
+Value NumberNode::evaluate(ExecState */*exec*/)
 {
   return Number(value);
 }
 
-KJSO StringNode::evaluate()
+// ------------------------------ StringNode -----------------------------------
+
+Value StringNode::evaluate(ExecState */*exec*/)
 {
   return String(value);
 }
 
-KJSO RegExpNode::evaluate()
+// ------------------------------ RegExpNode -----------------------------------
+
+Value RegExpNode::evaluate(ExecState *exec)
 {
   List list;
@@ -174 +185 @@
   list.append(f);
 
-  // very ugly
-  KJSO r = Global::current().get("RegExp");
-  RegExpObject *r2 = (RegExpObject*)r.imp();
-  return r2->construct(list);
-}
+  Object reg = exec->interpreter()->imp()->builtinRegExp();
+  return reg.construct(exec,list);
+}
+
+// ------------------------------ ThisNode -------------------------------------
 
 // ECMA 11.1.1
-KJSO ThisNode::evaluate()
-{
-  return Context::current()->thisValue();
-}
+Value ThisNode::evaluate(ExecState *exec)
+{
+  return exec->context().thisValue();
+}
+
+// ------------------------------ ResolveNode ----------------------------------
 
 // ECMA 11.1.2 & 10.1.4
-KJSO ResolveNode::evaluate()
-{
-  assert(Context::current());
-  const List *chain = Context::current()->pScopeChain();
-  assert(chain);
-  ListIterator scope = chain->begin();
-
-  while (scope != chain->end()) {
-    if (scope->hasProperty(ident)) {
-//        cout << "Resolve: found '" << ident.ascii() << "'"
-//          << " type " << scope->get(ident).imp()->typeInfo()->name << endl;
-      return Reference(*scope, ident);
+Value ResolveNode::evaluate(ExecState *exec)
+{
+  const List chain = exec->context().scopeChain();
+  ListIterator scope = chain.begin();
+
+  while (scope != chain.end()) {
+    ObjectImp *o = static_cast<ObjectImp*>((*scope).imp());
+
+    //cout << "Resolve: looking at '" << ident.ascii() << "'"
+    //     << " in " << (void*)o << " " << o->classInfo()->className << endl;
+    if (o->hasProperty(exec,ident)) {
+      //cout << "Resolve: FOUND '" << ident.ascii() << "'"
+      //     << " in " << (void*)o << " " << o->classInfo()->className << endl;
+      return Reference(Object(o), ident);
     }
     scope++;
@@ -204 +219 @@
 
   // identifier not found
-//  cout << "Resolve: didn't find '" << ident.ascii() << "'" << endl;
+  //cout << "Resolve: didn't find '" << ident.ascii() << "'" << endl;
   return Reference(Null(), ident);
 }
 
+// ------------------------------ GroupNode ------------------------------------
+
+GroupNode::~GroupNode()
+{
+}
+
+void GroupNode::ref()
+{
+  Node::ref();
+  if ( group )
+    group->ref();
+}
+
+bool GroupNode::deref()
+{
+  if ( group && group->deref() )
+    delete group;
+  return Node::deref();
+}
+
+// ECMA 11.1.6
+Value GroupNode::evaluate(ExecState *exec)
+{
+  return group->evaluate(exec);
+}
+
+// ------------------------------ ElisionNode ----------------------------------
+
+ElisionNode::~ElisionNode()
+{
+}
+
+void ElisionNode::ref()
+{
+  Node::ref();
+  if ( elision )
+    elision->ref();
+}
+
+bool ElisionNode::deref()
+{
+  if ( elision && elision->deref() )
+    delete elision;
+  return Node::deref();
+}
+
 // ECMA 11.1.4
-KJSO ArrayNode::evaluate()
-{
-  KJSO array;
+Value ElisionNode::evaluate(ExecState *exec)
+{
+  if (elision)
+    return Number(elision->evaluate(exec).toNumber(exec) + 1);
+  else
+    return Number(1);
+}
+
+// ------------------------------ ElementNode ----------------------------------
+
+ElementNode::~ElementNode()
+{
+}
+
+void ElementNode::ref()
+{
+  Node::ref();
+  if ( list )
+    list->ref();
+  if ( elision )
+    elision->ref();
+  if ( node )
+    node->ref();
+}
+
+bool ElementNode::deref()
+{
+  if ( list && list->deref() )
+    delete list;
+  if ( elision && elision->deref() )
+    delete elision;
+  if ( node && node->deref() )
+    delete node;
+  return Node::deref();
+}
+
+// ECMA 11.1.4
+Value ElementNode::evaluate(ExecState *exec)
+{
+  Object array;
+  Value val;
+  int length = 0;
+  int elisionLen = elision ? elision->evaluate(exec).toInt32(exec) : 0;
+  KJS_CHECKEXCEPTIONVALUE
+
+  if (list) {
+    array = Object(static_cast<ObjectImp*>(list->evaluate(exec).imp()));
+    KJS_CHECKEXCEPTIONVALUE
+    val = node->evaluate(exec).getValue(exec);
+    length = array.get(exec,"length").toInt32(exec);
+  } else {
+    Value newArr = exec->interpreter()->builtinArray().construct(exec,List::empty());
+    array = Object(static_cast<ObjectImp*>(newArr.imp()));
+    val = node->evaluate(exec).getValue(exec);
+    KJS_CHECKEXCEPTIONVALUE
+  }
+
+  array.put(exec, UString::from(elisionLen + length), val);
+
+  return array;
+}
+
+// ------------------------------ ArrayNode ------------------------------------
+
+ArrayNode::~ArrayNode()
+{
+}
+
+void ArrayNode::ref()
+{
+  Node::ref();
+  if ( element )
+    element->ref();
+  if ( elision )
+    elision->ref();
+}
+
+bool ArrayNode::deref()
+{
+  if ( element && element->deref() )
+    delete element;
+  if ( elision && elision->deref() )
+    delete elision;
+  return Node::deref();
+}
+
+// ECMA 11.1.4
+Value ArrayNode::evaluate(ExecState *exec)
+{
+  Object array;
   int length;
-  int elisionLen = elision ? elision->evaluate().toInt32() : 0;
+  int elisionLen = elision ? elision->evaluate(exec).toInt32(exec) : 0;
+  KJS_CHECKEXCEPTIONVALUE
 
   if (element) {
-    array = element->evaluate();
-    length = opt ? array.get("length").toInt32() : 0;
+    array = Object(static_cast<ObjectImp*>(element->evaluate(exec).imp()));
+    KJS_CHECKEXCEPTIONVALUE
+    length = opt ? array.get(exec,"length").toInt32(exec) : 0;
   } else {
-    array = Object::create(ArrayClass);
+    Value newArr = exec->interpreter()->builtinArray().construct(exec,List::empty());
+    array = Object(static_cast<ObjectImp*>(newArr.imp()));
     length = 0;
   }
 
   if (opt)
-    array.put("length", Number(elisionLen + length), DontEnum | DontDelete);
+    array.put(exec,"length", Number(elisionLen + length), DontEnum | DontDelete);
 
   return array;
 }
 
-// ECMA 11.1.4
-KJSO ElementNode::evaluate()
-{
-  KJSO array, val;
-  int length = 0;
-  int elisionLen = elision ? elision->evaluate().toInt32() : 0;
-
+// ------------------------------ ObjectLiteralNode ----------------------------
+
+ObjectLiteralNode::~ObjectLiteralNode()
+{
+}
+
+void ObjectLiteralNode::ref()
+{
+  Node::ref();
+  if ( list )
+    list->ref();
+}
+
+bool ObjectLiteralNode::deref()
+{
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
+}
+
+// ECMA 11.1.5
+Value ObjectLiteralNode::evaluate(ExecState *exec)
+{
+  if (list)
+    return list->evaluate(exec);
+
+  return exec->interpreter()->builtinObject().construct(exec,List::empty());
+}
+
+// ------------------------------ PropertyValueNode ----------------------------
+
+PropertyValueNode::~PropertyValueNode()
+{
+}
+
+void PropertyValueNode::ref()
+{
+  Node::ref();
+  if ( name )
+    name->ref();
+  if ( assign )
+    assign->ref();
+  if ( list )
+    list->ref();
+}
+
+bool PropertyValueNode::deref()
+{
+  if ( name && name->deref() )
+    delete name;
+  if ( assign && assign->deref() )
+    delete assign;
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
+}
+
+// ECMA 11.1.5
+Value PropertyValueNode::evaluate(ExecState *exec)
+{
+  Object obj;
   if (list) {
-    array = list->evaluate();
-    val = node->evaluate().getValue();
-    length = array.get("length").toInt32();
-  } else {
-    array = Object::create(ArrayClass);
-    val = node->evaluate().getValue();
+    obj = Object(static_cast<ObjectImp*>(list->evaluate(exec).imp()));
+    KJS_CHECKEXCEPTIONVALUE
   }
-
-  array.putArrayElement(UString::from(elisionLen + length), val);
-
-  return array;
-}
-
-// ECMA 11.1.4
-KJSO ElisionNode::evaluate()
-{
-  if (elision)
-    return Number(elision->evaluate().toNumber().value() + 1);
-  else
-    return Number(1);
-}
+  else {
+    Value newObj = exec->interpreter()->builtinObject().construct(exec,List::empty());
+    obj = Object(static_cast<ObjectImp*>(newObj.imp()));
+  }
+  Value n = name->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value a = assign->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = a.getValue(exec);
+
+  obj.put(exec,n.toString(exec), v);
+
+  return obj;
+}
+
+// ------------------------------ PropertyNode ---------------------------------
 
 // ECMA 11.1.5
-KJSO ObjectLiteralNode::evaluate()
-{
-  if (list)
-    return list->evaluate();
-
-  return Object::create(ObjectClass);
-}
-
-// ECMA 11.1.5
-KJSO PropertyValueNode::evaluate()
-{
-  KJSO obj;
-  if (list)
-    obj = list->evaluate();
-  else
-    obj = Object::create(ObjectClass);
-  KJSO n = name->evaluate();
-  KJSO a = assign->evaluate();
-  KJSO v = a.getValue();
-
-  obj.put(n.toString().value(), v);
-
-  return obj;
-}
-
-// ECMA 11.1.5
-KJSO PropertyNode::evaluate()
-{
-  KJSO s;
+Value PropertyNode::evaluate(ExecState */*exec*/)
+{
+  Value s;
 
   if (str.isNull()) {
@@ -298 +475 @@
 }
 
-// ECMA 11.1.6
-KJSO GroupNode::evaluate()
-{
-  return group->evaluate();
+// ------------------------------ AccessorNode1 --------------------------------
+
+AccessorNode1::~AccessorNode1()
+{
+}
+
+void AccessorNode1::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+}
+
+bool AccessorNode1::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  return Node::deref();
 }
 
 // ECMA 11.2.1a
-KJSO AccessorNode1::evaluate()
-{
-  KJSO e1 = expr1->evaluate();
-  KJSO v1 = e1.getValue();
-  KJSO e2 = expr2->evaluate();
-  KJSO v2 = e2.getValue();
-  Object o = v1.toObject();
-  String s = v2.toString();
+Value AccessorNode1::evaluate(ExecState *exec)
+{
+  Value e1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = e1.getValue(exec);
+  Value e2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = e2.getValue(exec);
+  Object o = v1.toObject(exec);
+  String s = v2.toString(exec);
   return Reference(o, s.value());
 }
 
+// ------------------------------ AccessorNode2 --------------------------------
+
+AccessorNode2::~AccessorNode2()
+{
+}
+
+void AccessorNode2::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool AccessorNode2::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.2.1b
-KJSO AccessorNode2::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  KJSO o = v.toObject();
+Value AccessorNode2::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  Object o = v.toObject(exec);
   return Reference(o, ident);
 }
 
+// ------------------------------ ArgumentListNode -----------------------------
+
+ArgumentListNode::ArgumentListNode(Node *e) : list(0L), expr(e)
+{
+}
+
+ArgumentListNode::ArgumentListNode(ArgumentListNode *l, Node *e)
+  : list(l), expr(e)
+{
+}
+
+ArgumentListNode::~ArgumentListNode()
+{
+}
+
+void ArgumentListNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+  if ( list )
+    list->ref();
+}
+
+bool ArgumentListNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
+}
+
+Value ArgumentListNode::evaluate(ExecState */*exec*/)
+{
+  assert(0);
+  return Value(); // dummy, see evaluateList()
+}
+
+// ECMA 11.2.4
+List ArgumentListNode::evaluateList(ExecState *exec)
+{
+  List l;
+  if (list) {
+    l = list->evaluateList(exec);
+    KJS_CHECKEXCEPTIONLIST
+  }
+
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONLIST
+  Value v = e.getValue(exec);
+
+  l.append(v);
+
+  return l;
+}
+
+// ------------------------------ ArgumentsNode --------------------------------
+
+ArgumentsNode::ArgumentsNode(ArgumentListNode *l) : list(l)
+{
+}
+
+ArgumentsNode::~ArgumentsNode()
+{
+}
+
+void ArgumentsNode::ref()
+{
+  Node::ref();
+  if ( list )
+    list->ref();
+}
+
+bool ArgumentsNode::deref()
+{
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
+}
+
+Value ArgumentsNode::evaluate(ExecState */*exec*/)
+{
+  assert(0);
+  return Value(); // dummy, see evaluateList()
+}
+
+// ECMA 11.2.4
+List ArgumentsNode::evaluateList(ExecState *exec)
+{
+  if (!list)
+    return List();
+
+  return list->evaluateList(exec);
+}
+
+// ------------------------------ NewExprNode ----------------------------------
+
 // ECMA 11.2.2
-KJSO NewExprNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-
-  List *argList = args ? args->evaluateList() : 0;
-
-  if (!v.isObject()) {
-    delete argList;
-    return throwError(TypeError, "Expression is no object. Cannot be new'ed");
+
+NewExprNode::~NewExprNode()
+{
+}
+
+void NewExprNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+  if ( args )
+    args->ref();
+}
+
+bool NewExprNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  if ( args && args->deref() )
+    delete args;
+  return Node::deref();
+}
+
+Value NewExprNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+
+  List argList;
+  if (args) {
+    argList = args->evaluateList(exec);
+    KJS_CHECKEXCEPTIONVALUE
   }
 
-  Constructor constr = Constructor::dynamicCast(v);
-  if (constr.isNull()) {
-    delete argList;
-    return throwError(TypeError, "Expression is no constructor.");
+  if (v.type() != ObjectType) {
+    return throwError(exec, TypeError, "Expression is no object. Cannot be new'ed");
   }
 
-  if (!argList)
-    argList = new List;
-
-  KJSO res = constr.construct(*argList);
-
-  delete argList;
+  Object constr = Object(static_cast<ObjectImp*>(v.imp()));
+  if (!constr.implementsConstruct()) {
+    return throwError(exec, TypeError, "Expression is no constructor.");
+  }
+
+  Value res = constr.construct(exec,argList);
 
   return res;
 }
 
+// ------------------------------ FunctionCallNode -----------------------------
+
+FunctionCallNode::~FunctionCallNode()
+{
+}
+
+void FunctionCallNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+  if ( args )
+    args->ref();
+}
+
+bool FunctionCallNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  if ( args && args->deref() )
+    delete args;
+  return Node::deref();
+}
+
 // ECMA 11.2.3
-KJSO FunctionCallNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-
-  List *argList = args->evaluateList();
-
-  KJSO v = e.getValue();
-
-  if (!v.isObject()) {
+Value FunctionCallNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  List argList = args->evaluateList(exec);
+
+  KJS_CHECKEXCEPTIONVALUE
+
+  Value v = e.getValue(exec);
+
+  if (v.type() != ObjectType) {
 #ifndef NDEBUG
-    printInfo("Failed function call attempt on", e);
+    printInfo(exec, "WARNING: Failed function call attempt on", e, line);
 #endif
-    delete argList;
-    return throwError(TypeError, "Expression is no object. Cannot be called.");
+    return throwError(exec, TypeError, "Expression is no object. Cannot be called.");
   }
 
-  if (!v.implementsCall()) {
+  Object func = Object(static_cast<ObjectImp*>(v.imp()));
+
+  if (!func.implementsCall()) {
 #ifndef NDEBUG
-    printInfo("Failed function call attempt on", e);
+    printInfo(exec, "Failed function call attempt on", e, line);
 #endif
-    delete argList;
-    return throwError(TypeError, "Expression does not allow calls.");
+    return throwError(exec, TypeError, "Expression does not allow calls.");
   }
 
-  KJSO o;
-  if (e.isA(ReferenceType))
-    o = e.getBase();
+  Value thisVal;
+  if (e.type() == ReferenceType)
+    thisVal = e.getBase(exec);
   else
-    o = Null();
-
-  if (o.isA(ActivationType))
-    o = Null();
-
-#ifdef KJS_DEBUGGER
-  steppingInto(true);
-#endif
-
-  KJSO result = v.executeCall(o, argList);
-
-#ifdef KJS_DEBUGGER
-  steppingInto(false);
-#endif
-
-  delete argList;
+    thisVal = Null();
+
+  if (thisVal.type() == ObjectType &&
+      Object::dynamicCast(thisVal).inherits(&ActivationImp::info))
+    thisVal = Null();
+
+  if (thisVal.type() != ObjectType) {
+    // ECMA 11.2.3 says that in this situation the this value should be null.
+    // However, section 10.2.3 says that in the case where the value provided
+    // by the caller is null, the global object should be used. It also says
+    // that the section does not apply to interal functions, but for simplicity
+    // of implementation we use the global object anyway here. This guarantees
+    // that in host objects you always get a valid object for this.
+    // thisVal = Null();
+    thisVal = exec->interpreter()->globalObject();
+  }
+
+  Object thisObj = Object::dynamicCast(thisVal);
+  Value result = func.call(exec,thisObj, argList);
 
   return result;
 }
 
-#ifdef KJS_DEBUGGER
-void FunctionCallNode::steppingInto(bool in)
-{
-  Debugger *dbg = KJScriptImp::current()->debugger();
-  if (!dbg)
-    return;
-  if (in) {
-    // before entering function. Don't step inside if 'Next' is chosen.
-    previousMode = dbg->mode();
-    if (previousMode == Debugger::Next)
-      dbg->setMode(Debugger::Continue);
-  } else {
-    // restore mode after leaving function
-    dbg->setMode(previousMode);
+// ------------------------------ PostfixNode ----------------------------------
+
+PostfixNode::~PostfixNode()
+{
+}
+
+void PostfixNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool PostfixNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 11.3
+Value PostfixNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  Number n = v.toNumber(exec);
+
+  double newValue = (oper == OpPlusPlus) ? n.value() + 1 : n.value() - 1;
+  Value n2 = Number(newValue);
+
+  e.putValue(exec,n2);
+
+  return n;
+}
+
+// ------------------------------ DeleteNode -----------------------------------
+
+DeleteNode::~DeleteNode()
+{
+}
+
+void DeleteNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool DeleteNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 11.4.1
+Value DeleteNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  if (e.type() != ReferenceType)
+    return Boolean(true);
+  Value b = e.getBase(exec);
+  UString n = e.getPropertyName(exec);
+
+  // The spec doesn't mention what to do if the base is null... just return true
+  if (b.type() != ObjectType) {
+    assert(b.type() == NullType);
+    return Boolean(true);
   }
-}
-#endif
-
-KJSO ArgumentsNode::evaluate()
-{
-  assert(0);
-  return KJSO(); // dummy, see evaluateList()
-}
-
-// ECMA 11.2.4
-List* ArgumentsNode::evaluateList()
-{
-  if (!list)
-    return new List();
-
-  return list->evaluateList();
-}
-
-KJSO ArgumentListNode::evaluate()
-{
-  assert(0);
-  return KJSO(); // dummy, see evaluateList()
-}
-
-// ECMA 11.2.4
-List* ArgumentListNode::evaluateList()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-
-  if (!list) {
-    List *l = new List();
-    l->append(v);
-    return l;
-  }
-
-  List *l = list->evaluateList();
-  l->append(v);
-
-  return l;
-}
-
-// ECMA 11.8
-KJSO RelationalNode::evaluate()
-{
-  KJSO e1 = expr1->evaluate();
-  KJSO v1 = e1.getValue();
-  KJSO e2 = expr2->evaluate();
-  KJSO v2 = e2.getValue();
-
-  bool b;
-  if (oper == OpLess || oper == OpGreaterEq) {
-    int r = relation(v1, v2);
-    if (r < 0)
-      b = false;
-    else
-      b = (oper == OpLess) ? (r == 1) : (r == 0);
-  } else if (oper == OpGreater || oper == OpLessEq) {
-    int r = relation(v2, v1);
-    if (r < 0)
-      b = false;
-    else
-      b = (oper == OpGreater) ? (r == 1) : (r == 0);
-  } else if (oper == OpIn) {
-      /* Is all of this OK for host objects? */
-      if (!v2.isObject())
-          return throwError( TypeError,
-                             "Shift expression not an object into IN expression." );
-      b = v2.hasProperty(v1.toString().value());
-  } else {
-    /* TODO: should apply to Function _objects_ only */
-    if (!v2.derivedFrom("Function"))
-      return throwError(TypeError,
-                        "Called instanceof operator on non-function object." );
-    return hasInstance(v2, v1); /* TODO: make object member function */
-  }
-
-  return Boolean(b);
-}
-
-// ECMA 11.9
-KJSO EqualNode::evaluate()
-{
-  KJSO e1 = expr1->evaluate();
-  KJSO e2 = expr2->evaluate();
-  KJSO v1 = e1.getValue();
-  KJSO v2 = e2.getValue();
-
-  bool result;
-  if (oper == OpEqEq || oper == OpNotEq) {
-    // == and !=
-    bool eq = equal(v1, v2);
-    result = oper == OpEqEq ? eq : !eq;
-  } else {
-    // === and !==
-    bool eq = strictEqual(v1, v2);
-    result = oper == OpStrEq ? eq : !eq;
-  }
-  return Boolean(result);
-}
-
-// ECMA 11.10
-KJSO BitOperNode::evaluate()
-{
-  KJSO e1 = expr1->evaluate();
-  KJSO v1 = e1.getValue();
-  KJSO e2 = expr2->evaluate();
-  KJSO v2 = e2.getValue();
-  int i1 = v1.toInt32();
-  int i2 = v2.toInt32();
-  int result;
-  if (oper == OpBitAnd)
-    result = i1 & i2;
-  else if (oper == OpBitXOr)
-    result = i1 ^ i2;
-  else
-    result = i1 | i2;
-
-  return Number(result);
-}
-
-// ECMA 11.11
-KJSO BinaryLogicalNode::evaluate()
-{
-  KJSO e1 = expr1->evaluate();
-  KJSO v1 = e1.getValue();
-  Boolean b1 = v1.toBoolean();
-  if ((!b1.value() && oper == OpAnd) || (b1.value() && oper == OpOr))
-    return v1;
-
-  KJSO e2 = expr2->evaluate();
-  KJSO v2 = e2.getValue();
-
-  return v2;
-}
-
-// ECMA 11.12
-KJSO ConditionalNode::evaluate()
-{
-  KJSO e = logical->evaluate();
-  KJSO v = e.getValue();
-  Boolean b = v.toBoolean();
-
-  if (b.value())
-    e = expr1->evaluate();
-  else
-    e = expr2->evaluate();
-
-  return e.getValue();
-}
-
-// ECMA 11.13
-KJSO AssignNode::evaluate()
-{
-  KJSO l, e, v;
-  ErrorType err;
-  if (oper == OpEqual) {
-    l = left->evaluate();
-    e = expr->evaluate();
-    v = e.getValue();
-  } else {
-    l = left->evaluate();
-    KJSO v1 = l.getValue();
-    e = expr->evaluate();
-    KJSO v2 = e.getValue();
-    int i1 = v1.toInt32();
-    int i2 = v2.toInt32();
-    switch (oper) {
-    case OpMultEq:
-      v = mult(v1, v2, '*');
-      break;
-    case OpDivEq:
-      v = mult(v1, v2, '/');
-      break;
-    case OpPlusEq:
-      v = add(v1, v2, '+');
-      break;
-    case OpMinusEq:
-      v = add(v1, v2, '-');
-      break;
-    case OpLShift:
-      v = Number(i1 <<= i2);
-      break;
-    case OpRShift:
-      v = Number(i1 >>= i2);
-      break;
-    case OpURShift:
-      i1 = v1.toUInt32();
-      v = Number(i1 >>= i2);
-      break;
-    case OpAndEq:
-      v = Number(i1 &= i2);
-      break;
-    case OpXOrEq:
-      v = Number(i1 ^= i2);
-      break;
-    case OpOrEq:
-      v = Number(i1 |= i2);
-      break;
-    case OpModEq:
-      v = Number(i1 %= i2);
-      break;
-    default:
-      v = Undefined();
-    }
-    err = l.putValue(v);
-  };
-
-  err = l.putValue(v);
-  if (err == NoError)
-    return v;
-  else
-    return throwError(err, "Invalid reference.");
-}
-
-// ECMA 11.3
-KJSO PostfixNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Number n = v.toNumber();
-
-  double newValue = (oper == OpPlusPlus) ? n.value() + 1 : n.value() - 1;
-  KJSO n2 = Number(newValue);
-
-  e.putValue(n2);
-
-  return n;
-}
-
-// ECMA 11.4.1
-KJSO DeleteNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  if (!e.isA(ReferenceType))
-    return Boolean(true);
-  KJSO b = e.getBase();
-  UString n = e.getPropertyName();
-  bool ret = b.deleteProperty(n);
+
+  Object o = Object(static_cast<ObjectImp*>(b.imp()));
+
+  bool ret = o.deleteProperty(exec,n);
 
   return Boolean(ret);
 }
 
+// ------------------------------ VoidNode -------------------------------------
+
+VoidNode::~VoidNode()
+{
+}
+
+void VoidNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool VoidNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.4.2
-KJSO VoidNode::evaluate()
-{
-  KJSO dummy1 = expr->evaluate();
-  KJSO dummy2 = dummy1.getValue();
+Value VoidNode::evaluate(ExecState *exec)
+{
+  Value dummy1 = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value dummy2 = dummy1.getValue(exec);
 
   return Undefined();
 }
 
+// ------------------------------ TypeOfNode -----------------------------------
+
+TypeOfNode::~TypeOfNode()
+{
+}
+
+void TypeOfNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool TypeOfNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.4.3
-KJSO TypeOfNode::evaluate()
+Value TypeOfNode::evaluate(ExecState *exec)
 {
   const char *s = 0L;
-  KJSO e = expr->evaluate();
-  if (e.isA(ReferenceType)) {
-    KJSO b = e.getBase();
-    if (b.isA(NullType))
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  if (e.type() == ReferenceType) {
+    Value b = e.getBase(exec);
+    if (b.type() == NullType)
       return String("undefined");
   }
-  KJSO v = e.getValue();
+  Value v = e.getValue(exec);
   switch (v.type())
     {
@@ -699 +929 @@
       break;
     default:
-      if (v.implementsCall())
+      if (v.type() == ObjectType && static_cast<ObjectImp*>(v.imp())->implementsCall())
         s = "function";
       else
@@ -709 +939 @@
 }
 
+// ------------------------------ PrefixNode -----------------------------------
+
+PrefixNode::~PrefixNode()
+{
+}
+
+void PrefixNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool PrefixNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.4.4 and 11.4.5
-KJSO PrefixNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Number n = v.toNumber();
+Value PrefixNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  Number n = v.toNumber(exec);
 
   double newValue = (oper == OpPlusPlus) ? n.value() + 1 : n.value() - 1;
-  KJSO n2 = Number(newValue);
-
-  e.putValue(n2);
+  Value n2 = Number(newValue);
+
+  e.putValue(exec,n2);
 
   return n2;
 }
 
+// ------------------------------ UnaryPlusNode --------------------------------
+
+UnaryPlusNode::~UnaryPlusNode()
+{
+}
+
+void UnaryPlusNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool UnaryPlusNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.4.6
-KJSO UnaryPlusNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-
-  return v.toNumber();
+Value UnaryPlusNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+
+  return Number(v.toNumber(exec)); /* TODO: optimize */
+}
+
+// ------------------------------ NegateNode -----------------------------------
+
+NegateNode::~NegateNode()
+{
+}
+
+void NegateNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool NegateNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
 }
 
 // ECMA 11.4.7
-KJSO NegateNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Number n = v.toNumber();
+Value NegateNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  Number n = v.toNumber(exec);
 
   double d = -n.value();
@@ -745 +1038 @@
 }
 
+// ------------------------------ BitwiseNotNode -------------------------------
+
+BitwiseNotNode::~BitwiseNotNode()
+{
+}
+
+void BitwiseNotNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool BitwiseNotNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.4.8
-KJSO BitwiseNotNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  int i32 = v.toInt32();
+Value BitwiseNotNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  int i32 = v.toInt32(exec);
 
   return Number(~i32);
 }
 
+// ------------------------------ LogicalNotNode -------------------------------
+
+LogicalNotNode::~LogicalNotNode()
+{
+}
+
+void LogicalNotNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool LogicalNotNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 11.4.9
-KJSO LogicalNotNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Boolean b = v.toBoolean();
-
-  return Boolean(!b.value());
+Value LogicalNotNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  bool b = v.toBoolean(exec);
+
+  return Boolean(!b);
+}
+
+// ------------------------------ MultNode -------------------------------------
+
+MultNode::~MultNode()
+{
+}
+
+void MultNode::ref()
+{
+  Node::ref();
+  if ( term1 )
+    term1->ref();
+  if ( term2 )
+    term2->ref();
+}
+
+bool MultNode::deref()
+{
+  if ( term1 && term1->deref() )
+    delete term1;
+  if ( term2 && term2->deref() )
+    delete term2;
+  return Node::deref();
 }
 
 // ECMA 11.5
-KJSO MultNode::evaluate()
-{
-  KJSO t1 = term1->evaluate();
-  KJSO v1 = t1.getValue();
-
-  KJSO t2 = term2->evaluate();
-  KJSO v2 = t2.getValue();
-
-  return mult(v1, v2, oper);
+Value MultNode::evaluate(ExecState *exec)
+{
+  Value t1 = term1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = t1.getValue(exec);
+
+  Value t2 = term2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = t2.getValue(exec);
+
+  return mult(exec,v1, v2, oper);
+}
+
+// ------------------------------ AddNode --------------------------------------
+
+AddNode::~AddNode()
+{
+}
+
+void AddNode::ref()
+{
+  Node::ref();
+  if ( term1 )
+    term1->ref();
+  if ( term2 )
+    term2->ref();
+}
+
+bool AddNode::deref()
+{
+  if ( term1 && term1->deref() )
+    delete term1;
+  if ( term2 && term2->deref() )
+    delete term2;
+  return Node::deref();
+}
+
+// ECMA 11.6
+Value AddNode::evaluate(ExecState *exec)
+{
+  Value t1 = term1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = t1.getValue(exec);
+
+  Value t2 = term2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = t2.getValue(exec);
+
+  return add(exec,v1, v2, oper);
+}
+
+// ------------------------------ ShiftNode ------------------------------------
+
+ShiftNode::~ShiftNode()
+{
+}
+
+void ShiftNode::ref()
+{
+  Node::ref();
+  if ( term1 )
+    term1->ref();
+  if ( term2 )
+    term2->ref();
+}
+
+bool ShiftNode::deref()
+{
+  if ( term1 && term1->deref() )
+    delete term1;
+  if ( term2 && term2->deref() )
+    delete term2;
+  return Node::deref();
 }
 
 // ECMA 11.7
-KJSO ShiftNode::evaluate()
-{
-  KJSO t1 = term1->evaluate();
-  KJSO v1 = t1.getValue();
-  KJSO t2 = term2->evaluate();
-  KJSO v2 = t2.getValue();
-  unsigned int i2 = v2.toUInt32();
+Value ShiftNode::evaluate(ExecState *exec)
+{
+  Value t1 = term1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = t1.getValue(exec);
+  Value t2 = term2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = t2.getValue(exec);
+  unsigned int i2 = v2.toUInt32(exec);
   i2 &= 0x1f;
 
@@ -790 +1215 @@
   switch (oper) {
   case OpLShift:
-    result = v1.toInt32() << i2;
+    result = v1.toInt32(exec) << i2;
     break;
   case OpRShift:
-    result = v1.toInt32() >> i2;
+    result = v1.toInt32(exec) >> i2;
     break;
   case OpURShift:
-    result = v1.toUInt32() >> i2;
+    result = v1.toUInt32(exec) >> i2;
     break;
   default:
@@ -806 +1231 @@
 }
 
-// ECMA 11.6
-KJSO AddNode::evaluate()
-{
-  KJSO t1 = term1->evaluate();
-  KJSO v1 = t1.getValue();
-
-  KJSO t2 = term2->evaluate();
-  KJSO v2 = t2.getValue();
-
-  return add(v1, v2, oper);
+// ------------------------------ RelationalNode -------------------------------
+
+RelationalNode::~RelationalNode()
+{
+}
+
+void RelationalNode::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+}
+
+bool RelationalNode::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  return Node::deref();
+}
+
+// ECMA 11.8
+Value RelationalNode::evaluate(ExecState *exec)
+{
+  Value e1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = e1.getValue(exec);
+  Value e2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = e2.getValue(exec);
+
+  bool b;
+  if (oper == OpLess || oper == OpGreaterEq) {
+    int r = relation(exec, v1, v2);
+    if (r < 0)
+      b = false;
+    else
+      b = (oper == OpLess) ? (r == 1) : (r == 0);
+  } else if (oper == OpGreater || oper == OpLessEq) {
+    int r = relation(exec, v2, v1);
+    if (r < 0)
+      b = false;
+    else
+      b = (oper == OpGreater) ? (r == 1) : (r == 0);
+  } else if (oper == OpIn) {
+      // Is all of this OK for host objects?
+      if (v2.type() != ObjectType)
+          return throwError(exec,  TypeError,
+                             "Shift expression not an object into IN expression." );
+      Object o2(static_cast<ObjectImp*>(v2.imp()));
+      b = o2.hasProperty(exec,v1.toString(exec));
+  } else {
+    if (v2.type() != ObjectType)
+        return throwError(exec,  TypeError,
+                           "Called instanceof operator on non-object." );
+
+    Object o2(static_cast<ObjectImp*>(v2.imp()));
+    if (!o2.implementsHasInstance()) {
+      // According to the spec, only some types of objects "imlement" the [[HasInstance]] property.
+      // But we are supposed to throw an exception where the object does not "have" the [[HasInstance]]
+      // property. It seems that all object have the property, but not all implement it, so in this
+      // case we return false (consistent with mozilla)
+      return Boolean(false);
+      //      return throwError(exec, TypeError,
+      //                        "Object does not implement the [[HasInstance]] method." );
+    }
+    return o2.hasInstance(exec, v1);
+  }
+
+  return Boolean(b);
+}
+
+// ------------------------------ EqualNode ------------------------------------
+
+EqualNode::~EqualNode()
+{
+}
+
+void EqualNode::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+}
+
+bool EqualNode::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  return Node::deref();
+}
+
+// ECMA 11.9
+Value EqualNode::evaluate(ExecState *exec)
+{
+  Value e1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value e2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = e1.getValue(exec);
+  Value v2 = e2.getValue(exec);
+
+  bool result;
+  if (oper == OpEqEq || oper == OpNotEq) {
+    // == and !=
+    bool eq = equal(exec,v1, v2);
+    result = oper == OpEqEq ? eq : !eq;
+  } else {
+    // === and !==
+    bool eq = strictEqual(exec,v1, v2);
+    result = oper == OpStrEq ? eq : !eq;
+  }
+  return Boolean(result);
+}
+
+// ------------------------------ BitOperNode ----------------------------------
+
+BitOperNode::~BitOperNode()
+{
+}
+
+void BitOperNode::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+}
+
+bool BitOperNode::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  return Node::deref();
+}
+
+// ECMA 11.10
+Value BitOperNode::evaluate(ExecState *exec)
+{
+  Value e1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = e1.getValue(exec);
+  Value e2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = e2.getValue(exec);
+  int i1 = v1.toInt32(exec);
+  int i2 = v2.toInt32(exec);
+  int result;
+  if (oper == OpBitAnd)
+    result = i1 & i2;
+  else if (oper == OpBitXOr)
+    result = i1 ^ i2;
+  else
+    result = i1 | i2;
+
+  return Number(result);
+}
+
+// ------------------------------ BinaryLogicalNode ----------------------------
+
+BinaryLogicalNode::~BinaryLogicalNode()
+{
+}
+
+void BinaryLogicalNode::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+}
+
+bool BinaryLogicalNode::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  return Node::deref();
+}
+
+// ECMA 11.11
+Value BinaryLogicalNode::evaluate(ExecState *exec)
+{
+  Value e1 = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v1 = e1.getValue(exec);
+  bool b1 = v1.toBoolean(exec);
+  if ((!b1 && oper == OpAnd) || (b1 && oper == OpOr))
+    return v1;
+
+  Value e2 = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v2 = e2.getValue(exec);
+
+  return v2;
+}
+
+// ------------------------------ ConditionalNode ------------------------------
+
+ConditionalNode::~ConditionalNode()
+{
+}
+
+void ConditionalNode::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+  if ( logical )
+    logical->ref();
+}
+
+bool ConditionalNode::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  if ( logical && logical->deref() )
+    delete logical;
+  return Node::deref();
+}
+
+// ECMA 11.12
+Value ConditionalNode::evaluate(ExecState *exec)
+{
+  Value e = logical->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+  bool b = v.toBoolean(exec);
+
+  if (b)
+    e = expr1->evaluate(exec);
+  else
+    e = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return e.getValue(exec);
+}
+
+// ------------------------------ AssignNode -----------------------------------
+
+AssignNode::~AssignNode()
+{
+}
+
+void AssignNode::ref()
+{
+  Node::ref();
+  if ( left )
+    left->ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool AssignNode::deref()
+{
+  if ( left && left->deref() )
+    delete left;
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 11.13
+Value AssignNode::evaluate(ExecState *exec)
+{
+
+  Value l, e, v;
+  if (oper == OpEqual) {
+    l = left->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    e = expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    v = e.getValue(exec);
+  } else {
+    l = left->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    Value v1 = l.getValue(exec);
+    e = expr->evaluate(exec);
+    KJS_CHECKEXCEPTIONVALUE
+    Value v2 = e.getValue(exec);
+    int i1 = v1.toInt32(exec);
+    int i2 = v2.toInt32(exec);
+    unsigned int ui;
+    switch (oper) {
+    case OpMultEq:
+      v = mult(exec, v1, v2, '*');
+      break;
+    case OpDivEq:
+      v = mult(exec, v1, v2, '/');
+      break;
+    case OpPlusEq:
+      v = add(exec, v1, v2, '+');
+      break;
+    case OpMinusEq:
+      v = add(exec, v1, v2, '-');
+      break;
+    case OpLShift:
+      v = Number(i1 <<= i2);
+      break;
+    case OpRShift:
+      v = Number(i1 >>= i2);
+      break;
+    case OpURShift:
+      ui = v1.toUInt32(exec);
+      v = Number(ui >>= i2);
+      break;
+    case OpAndEq:
+      v = Number(i1 &= i2);
+      break;
+    case OpXOrEq:
+      v = Number(i1 ^= i2);
+      break;
+    case OpOrEq:
+      v = Number(i1 |= i2);
+      break;
+    case OpModEq: {
+      double d1 = v1.toNumber(exec);
+      double d2 = v2.toNumber(exec);
+      v = Number(fmod(d1,d2));
+    }
+      break;
+    default:
+      v = Undefined();
+    }
+  };
+  l.putValue(exec,v);
+
+  KJS_CHECKEXCEPTIONVALUE
+
+  return v;
+}
+
+// ------------------------------ CommaNode ------------------------------------
+
+CommaNode::~CommaNode()
+{
+}
+
+void CommaNode::ref()
+{
+  Node::ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+}
+
+bool CommaNode::deref()
+{
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  return Node::deref();
 }
 
 // ECMA 11.14
-KJSO CommaNode::evaluate()
-{
-  KJSO e = expr1->evaluate();
-  KJSO dummy = e.getValue(); // ignore return value
-  e = expr2->evaluate();
-
-  return e.getValue();
+Value CommaNode::evaluate(ExecState *exec)
+{
+  Value e = expr1->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value dummy = e.getValue(exec); // ignore return value
+  e = expr2->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return e.getValue(exec);
+}
+
+// ------------------------------ StatListNode ---------------------------------
+
+StatListNode::~StatListNode()
+{
+}
+
+void StatListNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( list )
+    list->ref();
+}
+
+bool StatListNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
 }
 
 // ECMA 12.1
-Completion BlockNode::execute()
-{
-  if (!statlist)
-    return Completion(Normal);
-
-  return statlist->execute();
-}
-
-// ECMA 12.1
-Completion StatListNode::execute()
+Completion StatListNode::execute(ExecState *exec)
 {
   if (!list) {
-    Completion c = statement->execute();
+    Completion c = statement->execute(exec);
     KJS_ABORTPOINT
-    if (KJScriptImp::hadException()) {
-      KJSO ex = KJScriptImp::exception();
-      KJScriptImp::clearException();
+    if (exec->hadException()) {
+      Value ex = exec->exception();
+      exec->clearException();
       return Completion(Throw, ex);
-    } else
+    }
+    else
       return c;
   }
 
-  Completion l = list->execute();
+  Completion l = list->execute(exec);
   KJS_ABORTPOINT
   if (l.complType() != Normal)
     return l;
-  Completion e = statement->execute();
+  Completion e = statement->execute(exec);
   KJS_ABORTPOINT;
-  if (KJScriptImp::hadException()) {
-    KJSO ex = KJScriptImp::exception();
-    KJScriptImp::clearException();
+
+  if (exec->hadException()) {
+    Value ex = exec->exception();
+    exec->clearException();
     return Completion(Throw, ex);
   }
 
-  KJSO v = e.isValueCompletion() ? e.value() : l.value();
+  Value v = e.isValueCompletion() ? e.value() : l.value();
 
   return Completion(e.complType(), v, e.target() );
 }
 
+void StatListNode::processVarDecls(ExecState *exec)
+{
+  statement->processVarDecls(exec);
+
+  if (list)
+    list->processVarDecls(exec);
+}
+
+// ------------------------------ AssignExprNode -------------------------------
+
+AssignExprNode::~AssignExprNode()
+{
+}
+
+void AssignExprNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool AssignExprNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 12.2
-Completion VarStatementNode::execute()
-{
-  KJS_BREAKPOINT;
-
-  (void) list->evaluate(); // returns 0L
-
-  return Completion(Normal);
+Value AssignExprNode::evaluate(ExecState *exec)
+{
+  return expr->evaluate(exec);
+}
+
+// ------------------------------ VarDeclNode ----------------------------------
+
+VarDeclNode::VarDeclNode(const UString *id, AssignExprNode *in)
+    : ident(*id), init(in)
+{
+}
+
+VarDeclNode::~VarDeclNode()
+{
+}
+
+void VarDeclNode::ref()
+{
+  Node::ref();
+  if ( init )
+    init->ref();
+}
+
+bool VarDeclNode::deref()
+{
+  if ( init && init->deref() )
+    delete init;
+  return Node::deref();
 }
 
 // ECMA 12.2
-KJSO VarDeclNode::evaluate()
-{
-  KJSO variable = Context::current()->variableObject();
-
-  KJSO val, tmp;
+Value VarDeclNode::evaluate(ExecState *exec)
+{
+  Object variable = Object::dynamicCast(exec->context().variableObject());
+
+  Value val, tmp;
   if (init) {
-      tmp = init->evaluate();
-      val = tmp.getValue();
+      tmp = init->evaluate(exec);
+      KJS_CHECKEXCEPTIONVALUE
+      val = tmp.getValue(exec);
   } else {
-      if ( variable.hasProperty( ident ) ) // already declared ?
-          return KJSO();
+      if ( variable.hasProperty(exec, ident ) ) // already declared ?
+          return Value();
       val = Undefined();
   }
-  variable.put(ident, val, DontDelete);
-
-  // spec wants to return ident. But what for ? Will be ignored above.
-  return KJSO();
-}
+
+#ifdef KJS_VERBOSE
+  printInfo(exec,(UString("new variable ")+ident).cstring().c_str(),val);
+#endif
+  // We use Internal to bypass all checks in derived objects, e.g. so that
+  // "var location" creates a dynamic property instead of activating window.location.
+  variable.put(exec, ident, val, DontDelete | Internal);
+
+  return String(ident);
+}
+
+void VarDeclNode::processVarDecls(ExecState *exec)
+{
+  Object variable = exec->context().variableObject();
+  variable.put(exec,ident, Undefined(), DontDelete);
+}
+
+// ------------------------------ VarDeclListNode ------------------------------
+
+VarDeclListNode::~VarDeclListNode()
+{
+}
+
+void VarDeclListNode::ref()
+{
+  Node::ref();
+  if ( list )
+    list->ref();
+  if ( var )
+    var->ref();
+}
+
+bool VarDeclListNode::deref()
+{
+  if ( list && list->deref() )
+    delete list;
+  if ( var && var->deref() )
+    delete var;
+  return Node::deref();
+}
+
 
 // ECMA 12.2
-KJSO VarDeclListNode::evaluate()
+Value VarDeclListNode::evaluate(ExecState *exec)
 {
   if (list)
-    (void) list->evaluate();
-
-  (void) var->evaluate();
-
-  return KJSO();
+    (void) list->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  (void) var->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+
+  return Undefined();
+}
+
+void VarDeclListNode::processVarDecls(ExecState *exec)
+{
+  if (list)
+    list->processVarDecls(exec);
+
+  var->processVarDecls(exec);
+}
+
+// ------------------------------ VarStatementNode -----------------------------
+
+VarStatementNode::~VarStatementNode()
+{
+}
+
+void VarStatementNode::ref()
+{
+  Node::ref();
+  if ( list )
+    list->ref();
+}
+
+bool VarStatementNode::deref()
+{
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
 }
 
 // ECMA 12.2
-KJSO AssignExprNode::evaluate()
-{
-  return expr->evaluate();
-}
+Completion VarStatementNode::execute(ExecState *exec)
+{
+  KJS_BREAKPOINT;
+
+  (void) list->evaluate(exec); // returns 0L
+  KJS_CHECKEXCEPTION
+
+  return Completion(Normal);
+}
+
+void VarStatementNode::processVarDecls(ExecState *exec)
+{
+  list->processVarDecls(exec);
+}
+
+// ------------------------------ BlockNode ------------------------------------
+
+BlockNode::~BlockNode()
+{
+}
+
+void BlockNode::ref()
+{
+  Node::ref();
+  if ( source )
+    source->ref();
+}
+
+bool BlockNode::deref()
+{
+  if ( source && source->deref() )
+    delete source;
+  return Node::deref();
+}
+
+// ECMA 12.1
+Completion BlockNode::execute(ExecState *exec)
+{
+  if (!source)
+    return Completion(Normal);
+
+  source->processFuncDecl(exec);
+
+  return source->execute(exec);
+}
+
+void BlockNode::processVarDecls(ExecState *exec)
+{
+  if (source)
+    source->processVarDecls(exec);
+}
+
+// ------------------------------ EmptyStatementNode ---------------------------
 
 // ECMA 12.3
-Completion EmptyStatementNode::execute()
+Completion EmptyStatementNode::execute(ExecState */*exec*/)
 {
   return Completion(Normal);
 }
 
+// ------------------------------ ExprStatementNode ----------------------------
+
+ExprStatementNode::~ExprStatementNode()
+{
+}
+
+void ExprStatementNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool ExprStatementNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 12.4
+Completion ExprStatementNode::execute(ExecState *exec)
+{
+  KJS_BREAKPOINT;
+
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  Value v = e.getValue(exec);
+
+  return Completion(Normal, v);
+}
+
+// ------------------------------ IfNode ---------------------------------------
+
+IfNode::~IfNode()
+{
+}
+
+void IfNode::ref()
+{
+  Node::ref();
+  if ( statement1 )
+    statement1->ref();
+  if ( statement2 )
+    statement2->ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool IfNode::deref()
+{
+  if ( statement1 && statement1->deref() )
+    delete statement1;
+  if ( statement2 && statement2->deref() )
+    delete statement2;
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 12.5
+Completion IfNode::execute(ExecState *exec)
+{
+  KJS_BREAKPOINT;
+
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  Value v = e.getValue(exec);
+  bool b = v.toBoolean(exec);
+
+  // if ... then
+  if (b)
+    return statement1->execute(exec);
+
+  // no else
+  if (!statement2)
+    return Completion(Normal);
+
+  // else
+  return statement2->execute(exec);
+}
+
+void IfNode::processVarDecls(ExecState *exec)
+{
+  statement1->processVarDecls(exec);
+
+  if (statement2)
+    statement2->processVarDecls(exec);
+}
+
+// ------------------------------ DoWhileNode ----------------------------------
+
+DoWhileNode::~DoWhileNode()
+{
+}
+
+void DoWhileNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool DoWhileNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 12.6.1
+Completion DoWhileNode::execute(ExecState *exec)
+{
+  KJS_BREAKPOINT;
+
+  Value be, bv;
+  Completion c;
+  Value value;
+
+  do {
+    // bail out on error
+    KJS_CHECKEXCEPTION
+
+    c = statement->execute(exec);
+    if (!((c.complType() == Continue) && ls.contains(c.target()))) {
+      if ((c.complType() == Break) && ls.contains(c.target()))
+        return Completion(Normal, value);
+      if (c.complType() != Normal)
+        return c;
+    }
+    be = expr->evaluate(exec);
+    KJS_CHECKEXCEPTION
+    bv = be.getValue(exec);
+  } while (bv.toBoolean(exec));
+
+  return Completion(Normal, value);
+}
+
+void DoWhileNode::processVarDecls(ExecState *exec)
+{
+  statement->processVarDecls(exec);
+}
+
+// ------------------------------ WhileNode ------------------------------------
+
+WhileNode::~WhileNode()
+{
+}
+
+void WhileNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool WhileNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
+// ECMA 12.6.2
+Completion WhileNode::execute(ExecState *exec)
+{
+  KJS_BREAKPOINT;
+
+  Value be, bv;
+  Completion c;
+  bool b(false);
+  Value value;
+
+  while (1) {
+    be = expr->evaluate(exec);
+    KJS_CHECKEXCEPTION
+    bv = be.getValue(exec);
+    b = bv.toBoolean(exec);
+
+    // bail out on error
+    KJS_CHECKEXCEPTION
+
+    if (!b)
+      return Completion(Normal, value);
+
+    c = statement->execute(exec);
+    if (c.isValueCompletion())
+      value = c.value();
+
+    if ((c.complType() == Continue) && ls.contains(c.target()))
+      continue;
+    if ((c.complType() == Break) && ls.contains(c.target()))
+      return Completion(Normal, value);
+    if (c.complType() != Normal)
+      return c;
+  }
+}
+
+void WhileNode::processVarDecls(ExecState *exec)
+{
+  statement->processVarDecls(exec);
+}
+
+// ------------------------------ ForNode --------------------------------------
+
+ForNode::~ForNode()
+{
+}
+
+void ForNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( expr1 )
+    expr1->ref();
+  if ( expr2 )
+    expr2->ref();
+  if ( expr3 )
+    expr3->ref();
+}
+
+bool ForNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( expr1 && expr1->deref() )
+    delete expr1;
+  if ( expr2 && expr2->deref() )
+    delete expr2;
+  if ( expr3 && expr3->deref() )
+    delete expr3;
+  return Node::deref();
+}
+
 // ECMA 12.6.3
-Completion ForNode::execute()
-{
-  KJSO e, v, cval;
-  Boolean b;
+Completion ForNode::execute(ExecState *exec)
+{
+  Value e, v, cval;
+  bool b;
 
   if (expr1) {
-    e = expr1->evaluate();
-    v = e.getValue();
+    e = expr1->evaluate(exec);
+    KJS_CHECKEXCEPTION
+    v = e.getValue(exec);
   }
   while (1) {
     if (expr2) {
-      e = expr2->evaluate();
-      v = e.getValue();
-      b = v.toBoolean();
-      if (b.value() == false)
+      e = expr2->evaluate(exec);
+      KJS_CHECKEXCEPTION
+      v = e.getValue(exec);
+      b = v.toBoolean(exec);
+      if (b == false)
         return Completion(Normal, cval);
     }
     // bail out on error
-    if (KJScriptImp::hadException())
-      return Completion(Throw, KJScriptImp::exception());
-
-    Completion c = stat->execute();
+    KJS_CHECKEXCEPTION
+
+    Completion c = statement->execute(exec);
     if (c.isValueCompletion())
       cval = c.value();
@@ -953 +2166 @@
     }
     if (expr3) {
-      e = expr3->evaluate();
-      v = e.getValue();
+      e = expr3->evaluate(exec);
+      KJS_CHECKEXCEPTION
+      v = e.getValue(exec);
     }
   }
 }
 
+void ForNode::processVarDecls(ExecState *exec)
+{
+  if (expr1)
+    expr1->processVarDecls(exec);
+
+  statement->processVarDecls(exec);
+}
+
+// ------------------------------ ForInNode ------------------------------------
+
+ForInNode::ForInNode(Node *l, Node *e, StatementNode *s)
+  : init(0L), lexpr(l), expr(e), varDecl(0L), statement(s)
+{
+}
+
+ForInNode::ForInNode(const UString *i, AssignExprNode *in, Node *e, StatementNode *s)
+  : ident(*i), init(in), expr(e), statement(s)
+{
+  // for( var foo = bar in baz )
+  varDecl = new VarDeclNode(&ident, init);
+  lexpr = new ResolveNode(&ident);
+}
+
+ForInNode::~ForInNode()
+{
+}
+
+void ForInNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( expr )
+    expr->ref();
+  if ( lexpr )
+    lexpr->ref();
+  if ( init )
+    init->ref();
+  if ( varDecl )
+    varDecl->ref();
+}
+
+bool ForInNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( expr && expr->deref() )
+    delete expr;
+  if ( lexpr && lexpr->deref() )
+    delete lexpr;
+  if ( init && init->deref() )
+    delete init;
+  if ( varDecl && varDecl->deref() )
+    delete varDecl;
+  return Node::deref();
+}
+
 // ECMA 12.6.4
-Completion ForInNode::execute()
-{
-  KJSO e, v, retval;
+Completion ForInNode::execute(ExecState *exec)
+{
+  Value e, retval;
+  Object v;
   Completion c;
-  VarDeclNode *vd = 0;
-  const PropList *lst, *curr;
-
-  // This should be done in the constructor
-  if (!lexpr) { // for( var foo = bar in baz )
-    vd = new VarDeclNode(&ident, init);
-    vd->evaluate();
-
-    lexpr = new ResolveNode(&ident);
+  List propList;
+
+  if ( varDecl ) {
+    varDecl->evaluate(exec);
+    KJS_CHECKEXCEPTION
   }
 
-  e = expr->evaluate();
-  v = e.getValue().toObject();
-  curr = lst = v.imp()->propList();
-
-  while (curr) {
-    if (!v.hasProperty(curr->name)) {
-      curr = curr->next;
+  e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  v = e.getValue(exec).toObject(exec);
+  propList = v.propList(exec);
+
+  ListIterator propIt = propList.begin();
+
+  while (propIt != propList.end()) {
+    UString name = propIt->getPropertyName(exec);
+    if (!v.hasProperty(exec,name)) {
+      propIt++;
       continue;
     }
 
-    e = lexpr->evaluate();
-    e.putValue(String(curr->name));
-
-    c = stat->execute();
+    e = lexpr->evaluate(exec);
+    KJS_CHECKEXCEPTION
+    e.putValue(exec,String(name));
+
+    c = statement->execute(exec);
     if (c.isValueCompletion())
       retval = c.value();
@@ -996 +2269 @@
         break;
       if (c.complType() != Normal) {
-        delete lst;
         return c;
       }
     }
 
-    curr = curr->next;
+    propIt++;
   }
 
-  delete lst;
+  // bail out on error
+  KJS_CHECKEXCEPTION
+
   return Completion(Normal, retval);
 }
 
-// ECMA 12.4
-Completion ExprStatementNode::execute()
+void ForInNode::processVarDecls(ExecState *exec)
+{
+  statement->processVarDecls(exec);
+}
+
+// ------------------------------ ContinueNode ---------------------------------
+
+// ECMA 12.7
+Completion ContinueNode::execute(ExecState *exec)
 {
   KJS_BREAKPOINT;
 
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-
-  return Completion(Normal, v);
-}
-
-// ECMA 12.5
-Completion IfNode::execute()
-{
-  KJS_BREAKPOINT;
-
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Boolean b = v.toBoolean();
-
-  // if ... then
-  if (b.value())
-    return statement1->execute();
-
-  // no else
-  if (!statement2)
-    return Completion(Normal);
-
-  // else
-  return statement2->execute();
-}
-
-// ECMA 12.6.1
-Completion DoWhileNode::execute()
-{
-  KJS_BREAKPOINT;
-
-  KJSO be, bv;
-  Completion c;
-  KJSO value;
-
-  do {
-    // bail out on error
-    if (KJScriptImp::hadException())
-      return Completion(Throw, KJScriptImp::exception());
-
-    c = statement->execute();
-    if (!((c.complType() == Continue) && ls.contains(c.target()))) {
-      if ((c.complType() == Break) && ls.contains(c.target()))
-        return Completion(Normal, value);
-      if (c.complType() != Normal)
-        return c;
-    }
-    be = expr->evaluate();
-    bv = be.getValue();
-  } while (bv.toBoolean().value());
-
-  return Completion(Normal, value);
-}
-
-// ECMA 12.6.2
-Completion WhileNode::execute()
-{
-  KJS_BREAKPOINT;
-
-  KJSO be, bv;
-  Completion c;
-  Boolean b(false);
-  KJSO value;
-
-  while (1) {
-    be = expr->evaluate();
-    bv = be.getValue();
-    b = bv.toBoolean();
-
-    // bail out on error
-    if (KJScriptImp::hadException())
-      return Completion(Throw, KJScriptImp::exception());
-
-    if (!b.value())
-      return Completion(Normal, value);
-
-    c = statement->execute();
-    if (c.isValueCompletion())
-      value = c.value();
-
-    if ((c.complType() == Continue) && ls.contains(c.target()))
-      continue;
-    if ((c.complType() == Break) && ls.contains(c.target()))
-      return Completion(Normal, value);
-    if (c.complType() != Normal)
-      return c;
-  }
-}
-
-// ECMA 12.7
-Completion ContinueNode::execute()
-{
-  KJS_BREAKPOINT;
-
-  KJSO dummy;
-  return Context::current()->seenLabels()->contains(ident) ?
+  Value dummy;
+  return exec->context().imp()->seenLabels()->contains(ident) ?
     Completion(Continue, dummy, ident) :
     Completion(Throw,
-               throwError(SyntaxError, "Label not found in containing block"));
-}
+               throwError(exec, SyntaxError, "Label not found in containing block"));
+}
+
+// ------------------------------ BreakNode ------------------------------------
 
 // ECMA 12.8
-Completion BreakNode::execute()
+Completion BreakNode::execute(ExecState *exec)
 {
   KJS_BREAKPOINT;
 
-  KJSO dummy;
-  return Context::current()->seenLabels()->contains(ident) ?
+  Value dummy;
+  return exec->context().imp()->seenLabels()->contains(ident) ?
     Completion(Break, dummy, ident) :
     Completion(Throw,
-               throwError(SyntaxError, "Label not found in containing block"));
+               throwError(exec, SyntaxError, "Label not found in containing block"));
+}
+
+// ------------------------------ ReturnNode -----------------------------------
+
+ReturnNode::~ReturnNode()
+{
+}
+
+void ReturnNode::ref()
+{
+  Node::ref();
+  if ( value )
+    value->ref();
+}
+
+bool ReturnNode::deref()
+{
+  if ( value && value->deref() )
+    delete value;
+  return Node::deref();
 }
 
 // ECMA 12.9
-Completion ReturnNode::execute()
+Completion ReturnNode::execute(ExecState *exec)
 {
   KJS_BREAKPOINT;
@@ -1135 +2343 @@
     return Completion(ReturnValue, Undefined());
 
-  KJSO e = value->evaluate();
-  KJSO v = e.getValue();
+  Value e = value->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  Value v = e.getValue(exec);
 
   return Completion(ReturnValue, v);
 }
 
+// ------------------------------ WithNode -------------------------------------
+
+WithNode::~WithNode()
+{
+}
+
+void WithNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool WithNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 12.10
-Completion WithNode::execute()
+Completion WithNode::execute(ExecState *exec)
 {
   KJS_BREAKPOINT;
 
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Object o = v.toObject();
-  Context::current()->pushScope(o);
-  Completion res = stat->execute();
-  Context::current()->popScope();
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  Value v = e.getValue(exec);
+  Object o = v.toObject(exec);
+  KJS_CHECKEXCEPTION
+  exec->context().imp()->pushScope(o);
+  Completion res = statement->execute(exec);
+  exec->context().imp()->popScope();
 
   return res;
+}
+
+void WithNode::processVarDecls(ExecState *exec)
+{
+  statement->processVarDecls(exec);
+}
+
+// ------------------------------ CaseClauseNode -------------------------------
+
+CaseClauseNode::~CaseClauseNode()
+{
+}
+
+void CaseClauseNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+  if ( list )
+    list->ref();
+}
+
+bool CaseClauseNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  if ( list && list->deref() )
+    delete list;
+  return Node::deref();
+}
+
+// ECMA 12.11
+Value CaseClauseNode::evaluate(ExecState *exec)
+{
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTIONVALUE
+  Value v = e.getValue(exec);
+
+  return v;
+}
+
+// ECMA 12.11
+Completion CaseClauseNode::evalStatements(ExecState *exec)
+{
+  if (list)
+    return list->execute(exec);
+  else
+    return Completion(Normal, Undefined());
+}
+
+void CaseClauseNode::processVarDecls(ExecState *exec)
+{
+  if (list)
+    list->processVarDecls(exec);
+}
+
+// ------------------------------ ClauseListNode -------------------------------
+
+ClauseListNode::~ClauseListNode()
+{
+}
+
+void ClauseListNode::ref()
+{
+  Node::ref();
+  if ( cl )
+    cl->ref();
+  if ( nx )
+    nx->ref();
+}
+
+bool ClauseListNode::deref()
+{
+  if ( cl && cl->deref() )
+    delete cl;
+  if ( nx && nx->deref() )
+    delete nx;
+  return Node::deref();
+}
+
+Value ClauseListNode::evaluate(ExecState */*exec*/)
+{
+  /* should never be called */
+  assert(false);
+  return Value();
 }
 
@@ -1167 +2487 @@
 }
 
+void ClauseListNode::processVarDecls(ExecState *exec)
+{
+  if (cl)
+    cl->processVarDecls(exec);
+  if (nx)
+    nx->processVarDecls(exec);
+}
+
+// ------------------------------ CaseBlockNode --------------------------------
+
+CaseBlockNode::~CaseBlockNode()
+{
+}
+
+void CaseBlockNode::ref()
+{
+  Node::ref();
+  if ( def )
+    def->ref();
+  if ( list1 )
+    list1->ref();
+  if ( list2 )
+    list2->ref();
+}
+
+bool CaseBlockNode::deref()
+{
+  if ( def && def->deref() )
+    delete def;
+  if ( list1 && list1->deref() )
+    delete list1;
+  if ( list2 && list2->deref() )
+    delete list2;
+  return Node::deref();
+}
+
+Value CaseBlockNode::evaluate(ExecState */*exec*/)
+{
+  /* should never be called */
+  assert(false);
+  return Value();
+}
+
 // ECMA 12.11
-Completion SwitchNode::execute()
-{
-  KJS_BREAKPOINT;
-
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-  Completion res = block->evalBlock(v);
-
-  if ((res.complType() == Break) && ls.contains(res.target()))
-    return Completion(Normal, res.value());
-  else
-    return res;
-}
-
-// ECMA 12.11
-Completion CaseBlockNode::evalBlock(const KJSO& input)
-{
-  KJSO v;
+Completion CaseBlockNode::evalBlock(ExecState *exec, const Value& input)
+{
+  Value v;
   Completion res;
   ClauseListNode *a = list1, *b = list2;
@@ -1194 +2542 @@
       clause = a->clause();
       a = a->next();
-      v = clause->evaluate();
-      if (strictEqual(input, v)) {
-        res = clause->evalStatements();
+      v = clause->evaluate(exec);
+      KJS_CHECKEXCEPTION
+      if (strictEqual(exec, input, v)) {
+        res = clause->evalStatements(exec);
         if (res.complType() != Normal)
           return res;
         while (a) {
-          res = a->clause()->evalStatements();
+          res = a->clause()->evalStatements(exec);
           if (res.complType() != Normal)
             return res;
@@ -1213 +2562 @@
     clause = b->clause();
     b = b->next();
-    v = clause->evaluate();
-    if (strictEqual(input, v)) {
-      res = clause->evalStatements();
+    v = clause->evaluate(exec);
+    KJS_CHECKEXCEPTION
+    if (strictEqual(exec, input, v)) {
+      res = clause->evalStatements(exec);
       if (res.complType() != Normal)
         return res;
@@ -1224 +2574 @@
   // default clause
   if (def) {
-    res = def->evalStatements();
+    res = def->evalStatements(exec);
     if (res.complType() != Normal)
       return res;
@@ -1232 +2582 @@
   while (b) {
     clause = b->clause();
-    res = clause->evalStatements();
+    res = clause->evalStatements(exec);
     if (res.complType() != Normal)
       return res;
@@ -1238 +2588 @@
   }
 
+  // bail out on error
+  KJS_CHECKEXCEPTION
+
   return Completion(Normal);
 }
 
+void CaseBlockNode::processVarDecls(ExecState *exec)
+{
+  if (list1)
+    list1->processVarDecls(exec);
+  if (def)
+    def->processVarDecls(exec);
+  if (list2)
+    list2->processVarDecls(exec);
+}
+
+// ------------------------------ SwitchNode -----------------------------------
+
+SwitchNode::~SwitchNode()
+{
+}
+
+void SwitchNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+  if ( block )
+    block->ref();
+}
+
+bool SwitchNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  if ( block && block->deref() )
+    delete block;
+  return Node::deref();
+}
+
 // ECMA 12.11
-KJSO CaseClauseNode::evaluate()
-{
-  KJSO e = expr->evaluate();
-  KJSO v = e.getValue();
-
-  return v;
-}
-
-// ECMA 12.11
-Completion CaseClauseNode::evalStatements()
-{
-  if (list)
-    return list->execute();
+Completion SwitchNode::execute(ExecState *exec)
+{
+  KJS_BREAKPOINT;
+
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  Value v = e.getValue(exec);
+  Completion res = block->evalBlock(exec,v);
+
+  if ((res.complType() == Break) && ls.contains(res.target()))
+    return Completion(Normal, res.value());
   else
-    return Completion(Normal, Undefined());
+    return res;
+}
+
+void SwitchNode::processVarDecls(ExecState *exec)
+{
+  block->processVarDecls(exec);
+}
+
+// ------------------------------ LabelNode ------------------------------------
+
+LabelNode::~LabelNode()
+{
+}
+
+void LabelNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+}
+
+bool LabelNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  return Node::deref();
 }
 
 // ECMA 12.12
-Completion LabelNode::execute()
+Completion LabelNode::execute(ExecState *exec)
 {
   Completion e;
 
-  if (!Context::current()->seenLabels()->push(label)) {
+  if (!exec->context().imp()->seenLabels()->push(label)) {
     return Completion( Throw,
-                       throwError(SyntaxError, "Duplicated label found" ));
+                       throwError(exec, SyntaxError, "Duplicated label found" ));
   };
-  e = stat->execute();
-  Context::current()->seenLabels()->pop();
+  e = statement->execute(exec);
+  exec->context().imp()->seenLabels()->pop();
 
   if ((e.complType() == Break) && (e.target() == label))
@@ -1277 +2687 @@
 }
 
+void LabelNode::processVarDecls(ExecState *exec)
+{
+  statement->processVarDecls(exec);
+}
+
+// ------------------------------ ThrowNode ------------------------------------
+
+ThrowNode::~ThrowNode()
+{
+}
+
+void ThrowNode::ref()
+{
+  Node::ref();
+  if ( expr )
+    expr->ref();
+}
+
+bool ThrowNode::deref()
+{
+  if ( expr && expr->deref() )
+    delete expr;
+  return Node::deref();
+}
+
 // ECMA 12.13
-Completion ThrowNode::execute()
+Completion ThrowNode::execute(ExecState *exec)
 {
   KJS_BREAKPOINT;
 
-  KJSO v = expr->evaluate().getValue();
+  Value e = expr->evaluate(exec);
+  KJS_CHECKEXCEPTION
+  Value v = e.getValue(exec);
+
+  // bail out on error
+  KJS_CHECKEXCEPTION
 
   return Completion(Throw, v);
 }
 
+// ------------------------------ CatchNode ------------------------------------
+
+CatchNode::~CatchNode()
+{
+}
+
+void CatchNode::ref()
+{
+  Node::ref();
+  if ( block )
+    block->ref();
+}
+
+bool CatchNode::deref()
+{
+  if ( block && block->deref() )
+    delete block;
+  return Node::deref();
+}
+
+Completion CatchNode::execute(ExecState */*exec*/)
+{
+  // should never be reached. execute(exec, arg) is used instead
+  assert(0L);
+  return Completion();
+}
+
 // ECMA 12.14
-Completion TryNode::execute()
+Completion CatchNode::execute(ExecState *exec, const Value &arg)
+{
+  /* TODO: correct ? Not part of the spec */
+
+  exec->clearException();
+
+  Object obj(new ObjectImp());
+  obj.put(exec, ident, arg, DontDelete);
+  exec->context().imp()->pushScope(obj);
+  Completion c = block->execute(exec);
+  exec->context().imp()->popScope();
+
+  return c;
+}
+
+void CatchNode::processVarDecls(ExecState *exec)
+{
+  block->processVarDecls(exec);
+}
+
+// ------------------------------ FinallyNode ----------------------------------
+
+FinallyNode::~FinallyNode()
+{
+}
+
+void FinallyNode::ref()
+{
+  Node::ref();
+  if ( block )
+    block->ref();
+}
+
+bool FinallyNode::deref()
+{
+  if ( block && block->deref() )
+    delete block;
+  return Node::deref();
+}
+
+// ECMA 12.14
+Completion FinallyNode::execute(ExecState *exec)
+{
+  return block->execute(exec);
+}
+
+void FinallyNode::processVarDecls(ExecState *exec)
+{
+  block->processVarDecls(exec);
+}
+
+// ------------------------------ TryNode --------------------------------------
+
+TryNode::~TryNode()
+{
+}
+
+void TryNode::ref()
+{
+  Node::ref();
+  if ( block )
+    block->ref();
+  if ( _final )
+    _final->ref();
+  if ( _catch )
+    _catch->ref();
+}
+
+bool TryNode::deref()
+{
+  if ( block && block->deref() )
+    delete block;
+  if ( _final && _final->deref() )
+    delete _final;
+  if ( _catch && _catch->deref() )
+    delete _catch;
+  return Node::deref();
+}
+
+// ECMA 12.14
+Completion TryNode::execute(ExecState *exec)
 {
   KJS_BREAKPOINT;
@@ -1294 +2841 @@
   Completion c, c2;
 
-  c = block->execute();
+  c = block->execute(exec);
 
   if (!_final) {
     if (c.complType() != Throw)
       return c;
-    return _catch->execute(c.value());
+    return _catch->execute(exec,c.value());
   }
 
   if (!_catch) {
-    c2 = _final->execute();
+    c2 = _final->execute(exec);
     return (c2.complType() == Normal) ? c : c2;
   }
 
   if (c.complType() == Throw)
-    c = _catch->execute(c.value());
-
-  c2 = _final->execute();
+    c = _catch->execute(exec,c.value());
+
+  c2 = _final->execute(exec);
   return (c2.complType() == Normal) ? c : c2;
 }
 
-Completion CatchNode::execute()
-{
-  // should never be reached. execute(const KJS &arg) is used instead
-  assert(0L);
-  return Completion();
-}
-
-// ECMA 12.14
-Completion CatchNode::execute(const KJSO &arg)
-{
-  /* TODO: correct ? Not part of the spec */
-  KJScriptImp::clearException();
-
-  Object obj;
-  obj.put(ident, arg, DontDelete);
-  Context::current()->pushScope(obj);
-  Completion c = block->execute();
-  Context::current()->popScope();
-
-  return c;
-}
-
-// ECMA 12.14
-Completion FinallyNode::execute()
-{
-  return block->execute();
-}
+void TryNode::processVarDecls(ExecState *exec)
+{
+  block->processVarDecls(exec);
+  if (_final)
+    _final->processVarDecls(exec);
+  if (_catch)
+    _catch->processVarDecls(exec);
+}
+
+// ------------------------------ ParameterNode --------------------------------
+
+ParameterNode::~ParameterNode()
+{
+}
+
+void ParameterNode::ref()
+{
+  Node::ref();
+  if ( next )
+    next->ref();
+}
+
+bool ParameterNode::deref()
+{
+  if ( next && next->deref() )
+    delete next;
+  return Node::deref();
+}
+
+ParameterNode* ParameterNode::append(const UString *i)
+{
+  ParameterNode *p = this;
+  while (p->next)
+    p = p->next;
+
+  p->next = new ParameterNode(i);
+
+  return this;
+}
+
+// ECMA 13
+Value ParameterNode::evaluate(ExecState */*exec*/)
+{
+  return Undefined();
+}
+
+// ------------------------------ FunctionBodyNode -----------------------------
+
 
 FunctionBodyNode::FunctionBodyNode(SourceElementsNode *s)
   : source(s)
 {
-#ifdef KJS_DEBUGGER
-  setLoc(-1, -1);
-#endif
+  setLoc(-1, -1, -1);
+  //fprintf(stderr,"FunctionBodyNode::FunctionBodyNode %p\n",this);
+}
+
+FunctionBodyNode::~FunctionBodyNode()
+{
+  //fprintf(stderr,"FunctionBodyNode::~FunctionBodyNode %p\n",this);
+}
+
+void FunctionBodyNode::ref()
+{
+  Node::ref();
+  if ( source )
+    source->ref();
+  //fprintf( stderr, "FunctionBodyNode::ref() %p. Refcount now %d\n", (void*)this, refcount);
+}
+
+bool FunctionBodyNode::deref()
+{
+  if ( source && source->deref() )
+    delete source;
+  //fprintf( stderr, "FunctionBodyNode::deref() %p. Refcount now %d\n", (void*)this, refcount-1);
+  return Node::deref();
 }
 
 // ECMA 13 + 14 for ProgramNode
-Completion FunctionBodyNode::execute()
+Completion FunctionBodyNode::execute(ExecState *exec)
 {
   /* TODO: workaround for empty body which I don't see covered by the spec */
@@ -1357 +2945 @@
     return Completion(ReturnValue, Undefined());
 
-  source->processFuncDecl();
-
-  return source->execute();
+  source->processFuncDecl(exec);
+
+  return source->execute(exec);
+}
+
+void FunctionBodyNode::processFuncDecl(ExecState *exec)
+{
+  if (source)
+    source->processFuncDecl(exec);
+}
+
+void FunctionBodyNode::processVarDecls(ExecState *exec)
+{
+  if (source)
+    source->processVarDecls(exec);
+}
+
+// ------------------------------ FuncDeclNode ---------------------------------
+
+FuncDeclNode::~FuncDeclNode()
+{
+}
+
+void FuncDeclNode::ref()
+{
+  Node::ref();
+  if ( param )
+    param->ref();
+  if ( body )
+    body->ref();
+}
+
+bool FuncDeclNode::deref()
+{
+  if ( param && param->deref() )
+    delete param;
+  if ( body && body->deref() )
+    delete body;
+  return Node::deref();
 }
 
 // ECMA 13
-void FuncDeclNode::processFuncDecl()
-{
-  const List *sc = Context::current()->pScopeChain();
-  /* TODO: let this be an object with [[Class]] property "Function" */
-  FunctionImp *fimp = new DeclaredFunctionImp(ident, body, sc);
-  Function func(fimp); // protect from GC
-  fimp->put("prototype", Object::create(ObjectClass), DontDelete);
+void FuncDeclNode::processFuncDecl(ExecState *exec)
+{
+  const List sc = exec->context().imp()->scopeChain();
+
+  // TODO: let this be an object with [[Class]] property "Function"
+  FunctionImp *fimp = new DeclaredFunctionImp(exec, ident, body, sc);
+  Object func(fimp); // protect from GC
+
+  //  Value proto = exec->interpreter()->builtinObject().construct(exec,List::empty());
+  List empty;
+  Value proto = exec->interpreter()->builtinObject().construct(exec,empty);
+  func.put(exec, "prototype", proto, Internal|DontDelete);
 
   int plen = 0;
@@ -1375 +3004 @@
     fimp->addParameter(p->ident());
 
-  fimp->setLength(plen);
-
-  Context::current()->variableObject().put(ident, func);
-}
+  func.put(exec, "length", Number(plen), ReadOnly|DontDelete|DontEnum);
+
+  exec->context().imp()->variableObject().put(exec,ident,func);
+
+  if (body) {
+    // hack the scope so that the function gets put as a property of func, and it's scope
+    // contains the func as well as our current scope
+    Object oldVar = exec->context().imp()->variableObject();
+    exec->context().imp()->setVariableObject(func);
+    exec->context().imp()->pushScope(func);
+    body->processFuncDecl(exec);
+    exec->context().imp()->popScope();
+    exec->context().imp()->setVariableObject(oldVar);
+  }
+}
+
+// ------------------------------ FuncExprNode ---------------------------------
+
+FuncExprNode::~FuncExprNode()
+{
+}
+
+void FuncExprNode::ref()
+{
+  Node::ref();
+  if ( param )
+    param->ref();
+  if ( body )
+    body->ref();
+}
+
+bool FuncExprNode::deref()
+{
+  if ( param && param->deref() )
+    delete param;
+  if ( body && body->deref() )
+    delete body;
+  return Node::deref();
+}
+
 
 // ECMA 13
-KJSO FuncExprNode::evaluate()
-{
-  const List *sc = Context::current()->pScopeChain();
-  FunctionImp *fimp = new DeclaredFunctionImp(UString::null, body, sc->copy());
-  Function ret(fimp);
+Value FuncExprNode::evaluate(ExecState *exec)
+{
+  const List sc = exec->context().scopeChain();
+  FunctionImp *fimp = new DeclaredFunctionImp(exec, UString::null, body, sc);
+  Value ret(fimp);
+  List empty;
+  Value proto = exec->interpreter()->builtinObject().construct(exec,empty);
+  fimp->put(exec, "prototype", proto, Internal|DontDelete);
 
   int plen = 0;
   for(ParameterNode *p = param; p != 0L; p = p->nextParam(), plen++)
     fimp->addParameter(p->ident());
-  fimp->setLength(plen);
+  fimp->put(exec,"length", Number(plen), ReadOnly|DontDelete|DontEnum);
 
   return ret;
 }
 
-ParameterNode* ParameterNode::append(const UString *i)
-{
-  ParameterNode *p = this;
-  while (p->next)
-    p = p->next;
-
-  p->next = new ParameterNode(i);
-
-  return this;
-}
-
-// ECMA 13
-KJSO ParameterNode::evaluate()
-{
-  return Undefined();
-}
-
-void ProgramNode::deleteGlobalStatements()
-{
-  source->deleteStatements();
+// ------------------------------ SourceElementNode ----------------------------
+
+SourceElementNode::~SourceElementNode()
+{
+}
+
+void SourceElementNode::ref()
+{
+  Node::ref();
+  if ( statement )
+    statement->ref();
+  if ( function )
+    function->ref();
+}
+
+bool SourceElementNode::deref()
+{
+  if ( statement && statement->deref() )
+    delete statement;
+  if ( function && function->deref() )
+    delete function;
+  return Node::deref();
 }
 
 // ECMA 14
-Completion SourceElementsNode::execute()
-{
-  if (KJScriptImp::hadException())
-    return Completion(Throw, KJScriptImp::exception());
+Completion SourceElementNode::execute(ExecState *exec)
+{
+  if (statement)
+    return statement->execute(exec);
+
+  return Completion(Normal);
+}
+
+// ECMA 14
+void SourceElementNode::processFuncDecl(ExecState *exec)
+{
+  if (function)
+    function->processFuncDecl(exec);
+}
+
+void SourceElementNode::processVarDecls(ExecState *exec)
+{
+  if (statement)
+    statement->processVarDecls(exec);
+}
+
+// ------------------------------ SourceElementsNode ---------------------------
+
+SourceElementsNode::~SourceElementsNode()
+{
+}
+
+void SourceElementsNode::ref()
+{
+  Node::ref();
+  if ( element )
+    element->ref();
+  if ( elements )
+    elements->ref();
+}
+
+bool SourceElementsNode::deref()
+{
+  if ( element && element->deref() )
+    delete element;
+  if ( elements && elements->deref() )
+    delete elements;
+  return Node::deref();
+}
+
+// ECMA 14
+Completion SourceElementsNode::execute(ExecState *exec)
+{
+  KJS_CHECKEXCEPTION
 
   if (!elements)
-    return element->execute();
-
-  Completion c1 = elements->execute();
-  if (KJScriptImp::hadException())
-    return Completion(Throw, KJScriptImp::exception());
+    return element->execute(exec);
+
+  Completion c1 = elements->execute(exec);
+  KJS_CHECKEXCEPTION
   if (c1.complType() != Normal)
     return c1;
 
-  Completion c2 = element->execute();
-  if (KJScriptImp::hadException())
-    return Completion(Throw, KJScriptImp::exception());
-
-  return c2;
+  Completion c2 = element->execute(exec);
+  KJS_CHECKEXCEPTION
+
+  // The spec says to return c2 here, but it seems that mozilla returns c1 if
+  // c2 doesn't have a value
+  if (c2.complType() == Normal && c2.value().isNull())
+    return c1;
+  else
+    return c2;
 }
 
 // ECMA 14
-void SourceElementsNode::processFuncDecl()
+void SourceElementsNode::processFuncDecl(ExecState *exec)
 {
   if (elements)
-    elements->processFuncDecl();
-
-  element->processFuncDecl();
-}
-
-void SourceElementsNode::deleteStatements()
-{
-  element->deleteStatements();
-
+    elements->processFuncDecl(exec);
+
+  element->processFuncDecl(exec);
+}
+
+void SourceElementsNode::processVarDecls(ExecState *exec)
+{
   if (elements)
-    elements->deleteStatements();
-}
-
-// ECMA 14
-Completion SourceElementNode::execute()
-{
-  if (statement)
-    return statement->execute();
-
-  return Completion(Normal);
-}
-
-// ECMA 14
-void SourceElementNode::processFuncDecl()
-{
-  if (function)
-    function->processFuncDecl();
-}
-
-void SourceElementNode::deleteStatements()
-{
-  delete statement;
-}
-
-ArgumentListNode::ArgumentListNode(Node *e) : list(0L), expr(e) {}
-
-VarDeclNode::VarDeclNode(const UString *id, AssignExprNode *in)
-    : ident(*id), init(in) { }
-
-ArgumentListNode::ArgumentListNode(ArgumentListNode *l, Node *e) :
-    list(l), expr(e) {}
-
-ArgumentsNode::ArgumentsNode(ArgumentListNode *l) : list(l) {}
+    elements->processVarDecls(exec);
+
+  element->processVarDecls(exec);
+}
+
+ProgramNode::ProgramNode(SourceElementsNode *s): FunctionBodyNode(s) {
+    //fprintf(stderr,"ProgramNode::ProgramNode %p\n",this);
+}
+
+ProgramNode::~ProgramNode() {
+    //fprintf(stderr,"ProgramNode::~ProgramNode %p\n",this);
+}

trunk/JavaScriptCore/kjs/nodes.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
@@ -23 +27 @@
 
 #include "internal.h"
-#include "ustring.h"
-#include "object.h"
-#include "types.h"
-#include "debugger.h"
+//#include "debugger.h"
+#ifndef NDEBUG
+#ifndef __osf__
+#include <list>
+#endif
+#endif
 
 namespace KJS {
 
-  class KJSO;
   class RegExp;
   class SourceElementsNode;
@@ -70 +75 @@
     Node();
     virtual ~Node();
-    virtual KJSO evaluate() = 0;
+    virtual Value evaluate(ExecState *exec) = 0;
+    virtual void processVarDecls(ExecState */*exec*/) {}
     int lineNo() const { return line; }
-    static Node *firstNode() { return first; }
-    static void setFirstNode(Node *n) { first = n; }
-    static void deleteAllNodes();
-#ifdef KJS_DEBUGGER
-    static bool setBreakpoint(Node *firstNode, int id, int line, bool set);
-    virtual bool setBreakpoint(int, int, bool) { return false; }
+
+  public:
+    // reference counting mechanism
+    virtual void ref() { refcount++; }
+#ifdef KJS_DEBUG_MEM
+    virtual bool deref() { assert( refcount > 0 ); return (!--refcount); }
+#else
+    virtual bool deref() { return (!--refcount); }
+#endif
+
+
+#ifdef KJS_DEBUG_MEM
+    static void finalCheck();
 #endif
   protected:
-    KJSO throwError(ErrorType e, const char *msg);
-  private:
-    // disallow assignment and copy-construction
-    Node(const Node &);
+    Value throwError(ExecState *exec, ErrorType e, const char *msg);
+    int line;
+    unsigned int refcount;
+    virtual int sourceId() const { return -1; }
+  private:
+#ifdef KJS_DEBUG_MEM
+    // List of all nodes, for debugging purposes. Don't remove!
+    static std::list<Node *> s_nodes;
+#endif
+    // disallow assignment
     Node& operator=(const Node&);
-    int line;
-    static  int nodeCount;
-    static Node *first;
-    Node *next, *prev;
+    Node(const Node &other);
   };
 
   class StatementNode : public Node {
   public:
-#ifdef KJS_DEBUGGER
-    StatementNode() : l0(-1), l1(-1), sid(-1), breakPoint(false) { }
-    void setLoc(int line0, int line1);
+    StatementNode();
+    ~StatementNode();
+    void setLoc(int line0, int line1, int sourceId);
     int firstLine() const { return l0; }
     int lastLine() const { return l1; }
     int sourceId() const { return sid; }
-    bool hitStatement();
-    bool abortStatement();
-    virtual bool setBreakpoint(int id, int line, bool set);
-#endif
-    virtual Completion execute() = 0;
+    bool hitStatement(ExecState *exec);
+    bool abortStatement(ExecState *exec);
+    virtual Completion execute(ExecState *exec) = 0;
     void pushLabel(const UString *id) {
       if (id) ls.push(*id);
@@ -110 +124 @@
     LabelStack ls;
   private:
-    KJSO evaluate() { return Undefined(); }
-#ifdef KJS_DEBUGGER
+    Value evaluate(ExecState */*exec*/) { return Undefined(); }
     int l0, l1;
     int sid;
     bool breakPoint;
-#endif
   };
 
   class NullNode : public Node {
   public:
-    KJSO evaluate();
+    NullNode() {}
+    Value evaluate(ExecState *exec);
   };
 
@@ -126 +139 @@
   public:
     BooleanNode(bool v) : value(v) {}
-    KJSO evaluate();
+    Value evaluate(ExecState *exec);
   private:
     bool value;
@@ -134 +147 @@
   public:
     NumberNode(double v) : value(v) { }
-    KJSO evaluate();
+    Value evaluate(ExecState *exec);
   private:
     double value;
@@ -142 +155 @@
   public:
     StringNode(const UString *v) { value = *v; }
-    KJSO evaluate();
+    Value evaluate(ExecState *exec);
   private:
     UString value;
@@ -151 +164 @@
     RegExpNode(const UString &p, const UString &f)
       : pattern(p), flags(f) { }
-    KJSO evaluate();
+    Value evaluate(ExecState *exec);
   private:
     UString pattern, flags;
@@ -158 +171 @@
   class ThisNode : public Node {
   public:
-    KJSO evaluate();
+    ThisNode() {}
+    Value evaluate(ExecState *exec);
   };
 
@@ -164 +178 @@
   public:
     ResolveNode(const UString *s) : ident(*s) { }
-    KJSO evaluate();
+    Value evaluate(ExecState *exec);
   private:
     UString ident;
@@ -172 +186 @@
   public:
     GroupNode(Node *g) : group(g) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~GroupNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *group;
@@ -180 +197 @@
   public:
     ElisionNode(ElisionNode *e) : elision(e) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ElisionNode();
+    Value evaluate(ExecState *exec);
   private:
     ElisionNode *elision;
@@ -190 +210 @@
     ElementNode(ElementNode *l, ElisionNode *e, Node *n)
       : list(l), elision(e), node(n) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ElementNode();
+    Value evaluate(ExecState *exec);
   private:
     ElementNode *list;
@@ -204 +227 @@
     ArrayNode(ElisionNode *eli, ElementNode *ele)
       : element(ele), elision(eli), opt(true) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ArrayNode();
+    Value evaluate(ExecState *exec);
   private:
     ElementNode *element;
@@ -214 +240 @@
   public:
     ObjectLiteralNode(Node *l) : list(l) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ObjectLiteralNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *list;
@@ -223 +252 @@
     PropertyValueNode(Node *n, Node *a, Node *l = 0L)
       : name(n), assign(a), list(l) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~PropertyValueNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *name, *assign, *list;
@@ -232 +264 @@
     PropertyNode(double d) : numeric(d) { }
     PropertyNode(const UString *s) : str(*s) { }
-    KJSO evaluate();
+    Value evaluate(ExecState *exec);
   private:
     double numeric;
@@ -241 +273 @@
   public:
     AccessorNode1(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~AccessorNode1();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr1;
@@ -250 +285 @@
   public:
     AccessorNode2(Node *e, const UString *s) : expr(e), ident(*s) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~AccessorNode2();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -260 +298 @@
     ArgumentListNode(Node *e);
     ArgumentListNode(ArgumentListNode *l, Node *e);
-    KJSO evaluate();
-    List *evaluateList();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ArgumentListNode();
+    Value evaluate(ExecState *exec);
+    List evaluateList(ExecState *exec);
   private:
     ArgumentListNode *list;
@@ -270 +311 @@
   public:
     ArgumentsNode(ArgumentListNode *l);
-    KJSO evaluate();
-    List *evaluateList();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ArgumentsNode();
+    Value evaluate(ExecState *exec);
+    List evaluateList(ExecState *exec);
   private:
     ArgumentListNode *list;
@@ -280 +324 @@
     NewExprNode(Node *e) : expr(e), args(0L) {}
     NewExprNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~NewExprNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -289 +336 @@
   public:
     FunctionCallNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
-    KJSO evaluate();
-#ifdef KJS_DEBUGGER
-    void steppingInto(bool in);
-    Debugger::Mode previousMode;
-#endif
+    virtual void ref();
+    virtual bool deref();
+    virtual ~FunctionCallNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -302 +348 @@
   public:
     PostfixNode(Node *e, Operator o) : expr(e), oper(o) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~PostfixNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -311 +360 @@
   public:
     DeleteNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~DeleteNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -319 +371 @@
   public:
     VoidNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~VoidNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -327 +382 @@
   public:
     TypeOfNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~TypeOfNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -335 +393 @@
   public:
     PrefixNode(Operator o, Node *e) : oper(o), expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~PrefixNode();
+    Value evaluate(ExecState *exec);
   private:
     Operator oper;
@@ -344 +405 @@
   public:
     UnaryPlusNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~UnaryPlusNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -352 +416 @@
   public:
     NegateNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~NegateNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -360 +427 @@
   public:
     BitwiseNotNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~BitwiseNotNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -368 +438 @@
   public:
     LogicalNotNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~LogicalNotNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -376 +449 @@
   public:
     MultNode(Node *t1, Node *t2, char op) : term1(t1), term2(t2), oper(op) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~MultNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *term1, *term2;
@@ -385 +461 @@
   public:
     AddNode(Node *t1, Node *t2, char op) : term1(t1), term2(t2), oper(op) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~AddNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *term1, *term2;
@@ -395 +474 @@
     ShiftNode(Node *t1, Operator o, Node *t2)
       : term1(t1), term2(t2), oper(o) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ShiftNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *term1, *term2;
@@ -405 +487 @@
     RelationalNode(Node *e1, Operator o, Node *e2) :
       expr1(e1), expr2(e2), oper(o) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~RelationalNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr1, *expr2;
@@ -415 +500 @@
     EqualNode(Node *e1, Operator o, Node *e2)
       : expr1(e1), expr2(e2), oper(o) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~EqualNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr1, *expr2;
@@ -425 +513 @@
     BitOperNode(Node *e1, Operator o, Node *e2) :
       expr1(e1), expr2(e2), oper(o) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~BitOperNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr1, *expr2;
@@ -431 +522 @@
   };
 
+  /** expr1 && expr2, expr1 || expr2 */
   class BinaryLogicalNode : public Node {
   public:
     BinaryLogicalNode(Node *e1, Operator o, Node *e2) :
       expr1(e1), expr2(e2), oper(o) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~BinaryLogicalNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr1, *expr2;
@@ -441 +536 @@
   };
 
+  /** The ternary operator, "logical ? expr1 : expr2" */
   class ConditionalNode : public Node {
   public:
     ConditionalNode(Node *l, Node *e1, Node *e2) :
       logical(l), expr1(e1), expr2(e2) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ConditionalNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *logical, *expr1, *expr2;
@@ -453 +552 @@
   public:
     AssignNode(Node *l, Operator o, Node *e) : left(l), oper(o), expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~AssignNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *left;
@@ -463 +565 @@
   public:
     CommaNode(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~CommaNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr1, *expr2;
@@ -472 +577 @@
     StatListNode(StatementNode *s) : statement(s), list(0L) { }
     StatListNode(StatListNode *l, StatementNode *s) : statement(s), list(l) { }
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~StatListNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     StatementNode *statement;
@@ -481 +590 @@
   public:
     AssignExprNode(Node *e) : expr(e) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~AssignExprNode();
+    Value evaluate(ExecState *exec);
   private:
     Node *expr;
@@ -489 +601 @@
   public:
     VarDeclNode(const UString *id, AssignExprNode *in);
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~VarDeclNode();
+    Value evaluate(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     UString ident;
@@ -499 +615 @@
     VarDeclListNode(VarDeclNode *v) : list(0L), var(v) {}
     VarDeclListNode(Node *l, VarDeclNode *v) : list(l), var(v) {}
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~VarDeclListNode();
+    Value evaluate(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     Node *list;
@@ -508 +628 @@
   public:
     VarStatementNode(VarDeclListNode *l) : list(l) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~VarStatementNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     VarDeclListNode *list;
@@ -515 +639 @@
   class BlockNode : public StatementNode {
   public:
-    BlockNode(StatListNode *s) : statlist(s) {}
-    Completion execute();
-  private:
-    StatListNode *statlist;
+    BlockNode(SourceElementsNode *s) : source(s) {}
+    virtual void ref();
+    virtual bool deref();
+    virtual ~BlockNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
+  private:
+    SourceElementsNode *source;
   };
 
@@ -524 +652 @@
   public:
     EmptyStatementNode() { } // debug
-    Completion execute();
+    virtual Completion execute(ExecState *exec);
   };
 
@@ -530 +658 @@
   public:
     ExprStatementNode(Node *e) : expr(e) { }
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ExprStatementNode();
+    virtual Completion execute(ExecState *exec);
   private:
     Node *expr;
@@ -539 +670 @@
     IfNode(Node *e, StatementNode *s1, StatementNode *s2)
       : expr(e), statement1(s1), statement2(s2) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~IfNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     Node *expr;
@@ -548 +683 @@
   public:
     DoWhileNode(StatementNode *s, Node *e) : statement(s), expr(e) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~DoWhileNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     StatementNode *statement;
@@ -557 +696 @@
   public:
     WhileNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~WhileNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     Node *expr;
@@ -566 +709 @@
   public:
     ForNode(Node *e1, Node *e2, Node *e3, StatementNode *s) :
-      expr1(e1), expr2(e2), expr3(e3), stat(s) {}
-    Completion execute();
+      expr1(e1), expr2(e2), expr3(e3), statement(s) {}
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ForNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     Node *expr1, *expr2, *expr3;
-    StatementNode *stat;
+    StatementNode *statement;
   };
 
   class ForInNode : public StatementNode {
   public:
-    ForInNode(Node *l, Node *e, StatementNode *s) :
-      init(0L), lexpr(l), expr(e), stat(s) {}
-    ForInNode(const UString *i, AssignExprNode *in, Node *e, StatementNode *s)
-      : ident(*i), init(in), lexpr(0L), expr(e), stat(s) {}
-    Completion execute();
+    ForInNode(Node *l, Node *e, StatementNode *s);
+    ForInNode(const UString *i, AssignExprNode *in, Node *e, StatementNode *s);
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ForInNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     UString ident;
     AssignExprNode *init;
     Node *lexpr, *expr;
-    StatementNode *stat;
+    VarDeclNode *varDecl;
+    StatementNode *statement;
   };
 
@@ -591 +741 @@
     ContinueNode() { }
     ContinueNode(const UString *i) : ident(*i) { }
-    Completion execute();
+    virtual Completion execute(ExecState *exec);
   private:
     UString ident;
@@ -600 +750 @@
     BreakNode() { }
     BreakNode(const UString *i) : ident(*i) { }
-    Completion execute();
+    virtual Completion execute(ExecState *exec);
   private:
     UString ident;
@@ -608 +758 @@
   public:
     ReturnNode(Node *v) : value(v) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ReturnNode();
+    virtual Completion execute(ExecState *exec);
   private:
     Node *value;
@@ -615 +768 @@
   class WithNode : public StatementNode {
   public:
-    WithNode(Node *e, StatementNode *s) : expr(e), stat(s) {}
-    Completion execute();
-  private:
-    Node *expr;
-    StatementNode *stat;
+    WithNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
+    virtual void ref();
+    virtual bool deref();
+    virtual ~WithNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
+  private:
+    Node *expr;
+    StatementNode *statement;
   };
 
@@ -625 +782 @@
   public:
     CaseClauseNode(Node *e, StatListNode *l) : expr(e), list(l) { }
-    KJSO evaluate();
-    Completion evalStatements();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~CaseClauseNode();
+    Value evaluate(ExecState *exec);
+    Completion evalStatements(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     Node *expr;
@@ -635 +796 @@
   public:
     ClauseListNode(CaseClauseNode *c) : cl(c), nx(0L) { }
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ClauseListNode();
     ClauseListNode* append(CaseClauseNode *c);
-    KJSO evaluate() { /* should never be called */ return KJSO(); }
+    Value evaluate(ExecState *exec);
     CaseClauseNode *clause() const { return cl; }
     ClauseListNode *next() const { return nx; }
+    virtual void processVarDecls(ExecState *exec);
   private:
     CaseClauseNode *cl;
@@ -648 +813 @@
     CaseBlockNode(ClauseListNode *l1, CaseClauseNode *d, ClauseListNode *l2)
       : list1(l1), def(d), list2(l2) { }
-    KJSO evaluate() { /* should never be called */ return KJSO(); }
-    Completion evalBlock(const KJSO& input);
+    virtual void ref();
+    virtual bool deref();
+    virtual ~CaseBlockNode();
+    Value evaluate(ExecState *exec);
+    Completion evalBlock(ExecState *exec, const Value& input);
+    virtual void processVarDecls(ExecState *exec);
   private:
     ClauseListNode *list1;
@@ -659 +828 @@
   public:
     SwitchNode(Node *e, CaseBlockNode *b) : expr(e), block(b) { }
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~SwitchNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     Node *expr;
@@ -667 +840 @@
   class LabelNode : public StatementNode {
   public:
-    LabelNode(const UString *l, StatementNode *s) : label(*l), stat(s) { }
-    Completion execute();
+    LabelNode(const UString *l, StatementNode *s) : label(*l), statement(s) { }
+    virtual void ref();
+    virtual bool deref();
+    virtual ~LabelNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     UString label;
-    StatementNode *stat;
+    StatementNode *statement;
   };
 
@@ -677 +854 @@
   public:
     ThrowNode(Node *e) : expr(e) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ThrowNode();
+    virtual Completion execute(ExecState *exec);
   private:
     Node *expr;
@@ -684 +864 @@
   class CatchNode : public StatementNode {
   public:
-    CatchNode(UString *i, StatementNode *b) : ident(*i), block(b) {}
-    Completion execute();
-    Completion execute(const KJSO &arg);
+    CatchNode(const UString *i, StatementNode *b) : ident(*i), block(b) {}
+    virtual void ref();
+    virtual bool deref();
+    virtual ~CatchNode();
+    virtual Completion execute(ExecState *exec);
+    Completion execute(ExecState *exec, const Value &arg);
+    virtual void processVarDecls(ExecState *exec);
   private:
     UString ident;
@@ -695 +879 @@
   public:
     FinallyNode(StatementNode *b) : block(b) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~FinallyNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     StatementNode *block;
@@ -704 +892 @@
     TryNode(StatementNode *b, Node *c = 0L, Node *f = 0L)
       : block(b), _catch((CatchNode*)c), _final((FinallyNode*)f) {}
-    Completion execute();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~TryNode();
+    virtual Completion execute(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     StatementNode *block;
@@ -715 +907 @@
     ParameterNode(const UString *i) : id(*i), next(0L) { }
     ParameterNode *append(const UString *i);
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~ParameterNode();
+    Value evaluate(ExecState *exec);
     UString ident() { return id; }
     ParameterNode *nextParam() { return next; }
@@ -726 +921 @@
   class FunctionBodyNode : public StatementNode {
   public:
-      FunctionBodyNode(SourceElementsNode *s);
-      Completion execute();
+    FunctionBodyNode(SourceElementsNode *s);
+    virtual void ref();
+    virtual bool deref();
+    virtual ~FunctionBodyNode();
+    Completion execute(ExecState *exec);
+    virtual void processFuncDecl(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   protected:
-      SourceElementsNode *source;
+    SourceElementsNode *source;
   };
 
@@ -736 +936 @@
     FuncDeclNode(const UString *i, ParameterNode *p, FunctionBodyNode *b)
       : ident(*i), param(p), body(b) { }
-    Completion execute() { /* empty */ return Completion(); }
-    void processFuncDecl();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~FuncDeclNode();
+    Completion execute(ExecState */*exec*/)
+      { /* empty */ return Completion(); }
+    void processFuncDecl(ExecState *exec);
   private:
     UString ident;
@@ -748 +952 @@
     FuncExprNode(ParameterNode *p, FunctionBodyNode *b)
         : param(p), body(b) { }
-    KJSO evaluate();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~FuncExprNode();
+    Value evaluate(ExecState *exec);
   private:
     ParameterNode *param;
@@ -758 +965 @@
     SourceElementNode(StatementNode *s) { statement = s; function = 0L; }
     SourceElementNode(FuncDeclNode *f) { function = f; statement = 0L;}
-    Completion execute();
-    virtual void processFuncDecl();
-    void deleteStatements();
+    virtual void ref();
+    virtual bool deref();
+    virtual ~SourceElementNode();
+    Completion execute(ExecState *exec);
+    virtual void processFuncDecl(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
   private:
     StatementNode *statement;
@@ -766 +976 @@
   };
 
+  // A linked list of source element nodes
   class SourceElementsNode : public StatementNode {
   public:
@@ -771 +982 @@
     SourceElementsNode(SourceElementsNode *s1, SourceElementNode *s2)
       { elements = s1; element = s2; }
-    Completion execute();
-    virtual void processFuncDecl();
-    void deleteStatements();
-  private:
-    SourceElementNode *element;
-    SourceElementsNode *elements;
+    virtual void ref();
+    virtual bool deref();
+    virtual ~SourceElementsNode();
+    Completion execute(ExecState *exec);
+    virtual void processFuncDecl(ExecState *exec);
+    virtual void processVarDecls(ExecState *exec);
+  private:
+    SourceElementNode *element; // 'this' element
+    SourceElementsNode *elements; // pointer to next
   };
 
   class ProgramNode : public FunctionBodyNode {
   public:
-    ProgramNode(SourceElementsNode *s) : FunctionBodyNode(s) { }
-    void deleteGlobalStatements();
+    ProgramNode(SourceElementsNode *s);
+    ~ProgramNode();
+  private:
+    // Disallow copy
+    ProgramNode(const ProgramNode &other);
   };
 

trunk/JavaScriptCore/kjs/number_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 "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "operations.h"
 #include "number_object.h"
+#include "error_object.h"
+
+#include "number_object.lut.h"
 
 using namespace KJS;
 
-NumberObject::NumberObject(const Object& funcProto, const Object &numProto)
-  : ConstructorImp(funcProto, 1)
+
+// ------------------------------ NumberInstanceImp ----------------------------
+
+const ClassInfo NumberInstanceImp::info = {"Number", 0, 0, 0};
+
+NumberInstanceImp::NumberInstanceImp(const Object &proto)
+  : ObjectImp(proto)
 {
-  // Number.Prototype
-  setPrototypeProperty(numProto);
+}
+// ------------------------------ NumberPrototypeImp ---------------------------
+
+// ECMA 15.7.4
+
+NumberPrototypeImp::NumberPrototypeImp(ExecState *exec,
+                                       ObjectPrototypeImp *objProto,
+                                       FunctionPrototypeImp *funcProto)
+  : NumberInstanceImp(Object(objProto))
+{
+  Value protect(this);
+  setInternalValue(Number(0));
+
+  // The constructor will be added later, after NumberObjectImp has been constructed
+
+  put(exec,"toString",       Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ToString,       1)), DontEnum);
+  put(exec,"toLocaleString", Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ToLocaleString, 0)), DontEnum);
+  put(exec,"valueOf",        Object(new NumberProtoFuncImp(exec,funcProto,NumberProtoFuncImp::ValueOf,        0)), DontEnum);
 }
 
-// ECMA 15.7.3
-KJSO NumberObject::get(const UString &p) const
+
+// ------------------------------ NumberProtoFuncImp ---------------------------
+
+NumberProtoFuncImp::NumberProtoFuncImp(ExecState *exec,
+                                       FunctionPrototypeImp *funcProto, int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
 {
-  double d;
-
-  if (p == "NaN")
-    d = NaN;
-  else if (p == "NEGATIVE_INFINITY")
-    d = -Inf;
-  else if (p == "POSITIVE_INFINITY")
-    d = Inf;
-  else
-    return Imp::get(p);
-
-  return Number(d);
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
 }
 
+
+bool NumberProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.7.4.2 - 15.7.4.7
+Value NumberProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &/*args*/)
+{
+  Value result;
+
+  // no generic function. "this" has to be a Number object
+  if (!thisObj.inherits(&NumberInstanceImp::info)) {
+    Object err = Error::create(exec,TypeError);
+    exec->setException(err);
+    return err;
+  }
+
+  // execute "toString()" or "valueOf()", respectively
+  Value v = thisObj.internalValue();
+  switch (id) {
+  case ToString:
+  case ToLocaleString: /* TODO */
+    result = String(v.toString(exec));
+    break;
+  case ValueOf:
+    result = Number(v.toNumber(exec));
+    break;
+  }
+
+  return result;
+}
+
+// ------------------------------ NumberObjectImp ------------------------------
+
+const ClassInfo NumberObjectImp::info = {"Number", &InternalFunctionImp::info, &numberTable, 0};
+//const ClassInfo NumberObjectImp::info = {"Number", 0, &numberTable, 0};
+
+/* Source for number_object.lut.h
+@begin numberTable 5
+  NaN                   NumberObjectImp::NaNValue       DontEnum
+  NEGATIVE_INFINITY     NumberObjectImp::NegInfinity    DontEnum
+  POSITIVE_INFINITY     NumberObjectImp::PosInfinity    DontEnum
+  MAX_VALUE             NumberObjectImp::MaxValue       DontEnum
+  MIN_VALUE             NumberObjectImp::MinValue       DontEnum
+@end
+*/
+NumberObjectImp::NumberObjectImp(ExecState *exec,
+                                 FunctionPrototypeImp *funcProto,
+                                 NumberPrototypeImp *numberProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
+  // Number.Prototype
+  put(exec,"prototype", Value(numberProto),DontEnum|DontDelete|ReadOnly);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+}
+
+Value NumberObjectImp::get(ExecState *exec, const UString &propertyName) const
+{
+  return lookupGetValue<NumberObjectImp, InternalFunctionImp>( exec, propertyName, &numberTable, this );
+}
+
+Value NumberObjectImp::getValueProperty(ExecState *, int token) const
+{
+  // ECMA 15.7.3
+  switch(token) {
+  case NaNValue:
+    return Number(NaN);
+  case NegInfinity:
+    return Number(-Inf);
+  case PosInfinity:
+    return Number(Inf);
+  case MaxValue:
+    return Number(1.7976931348623157E+308);
+  case MinValue:
+    return Number(5E-324);
+  }
+  return Null();
+}
+
+bool NumberObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+
 // ECMA 15.7.1
-Completion NumberObject::execute(const List &args)
+Object NumberObjectImp::construct(ExecState *exec, const List &args)
 {
+  Object proto = exec->interpreter()->builtinNumberPrototype();
+  Object obj(new NumberInstanceImp(proto));
+
   Number n;
   if (args.isEmpty())
     n = Number(0);
   else
-    n = args[0].toNumber();
+    n = args[0].toNumber(exec);
 
-  return Completion(ReturnValue, n);
+  obj.setInternalValue(n);
+
+  return obj;
+}
+
+bool NumberObjectImp::implementsCall() const
+{
+  return true;
 }
 
 // ECMA 15.7.2
-Object NumberObject::construct(const List &args)
+Value NumberObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
 {
-  Number n;
   if (args.isEmpty())
-    n = Number(0);
+    return Number(0);
   else
-    n = args[0].toNumber();
-
-  return Object::create(NumberClass, n);
+    return Number(args[0].toNumber(exec));
 }
-
-class NumberProtoFunc : public InternalFunctionImp {
-public:
-  NumberProtoFunc(int i) : id (i) { }
-  Completion execute(const List &);
-  enum { ToString, ToLocaleString, ValueOf };
-private:
-  int id;
-};
-
-// ECMA 15.7.4.2 - 15.7.4.7
-Completion NumberProtoFunc::execute(const List &)
-{
-  KJSO result;
-
-  Object thisObj = Object::dynamicCast(thisValue());
-
-  // no generic function. "this" has to be a Number object
-  if (thisObj.isNull() || thisObj.getClass() != NumberClass) {
-    result = Error::create(TypeError);
-    return Completion(ReturnValue, result);
-  }
-
-  // execute "toString()" or "valueOf()", respectively
-  KJSO v = thisObj.internalValue();
-  switch (id) {
-  case ToString:
-  case ToLocaleString: /* TODO */
-    result = v.toString();
-    break;
-  case ValueOf:
-    result = v.toNumber();
-    break;
-  }
-
-  return Completion(ReturnValue, result);
-}
-
-// ECMA 15.7.4
-NumberPrototype::NumberPrototype(const Object& proto)
-  : ObjectImp(NumberClass, Number(0), proto)
-{
-  // The constructor will be added later in NumberObject's constructor
-}
-
-KJSO NumberPrototype::get(const UString &p) const
-{
-  int t;
-  if (p == "toString")
-    t = NumberProtoFunc::ToString;
-  else if (p == "toLocaleString")
-    t = NumberProtoFunc::ToLocaleString;
-  else if (p == "valueOf")
-    t = NumberProtoFunc::ValueOf;
-  else
-    return Imp::get(p);
-
-  return Function(new NumberProtoFunc(t));
-}

trunk/JavaScriptCore/kjs/number_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _NUMBER_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class NumberObject : public ConstructorImp {
+  class NumberInstanceImp : public ObjectImp {
   public:
-    NumberObject(const Object& funcProto, const Object &numProto);
-    virtual KJSO get(const UString &p) const;
+    NumberInstanceImp(const Object &proto);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  };
+
+  /**
+   * @internal
+   *
+   * The initial value of Number.prototype (and thus all objects created
+   * with the Number constructor
+   */
+  class NumberPrototypeImp : public NumberInstanceImp {
+  public:
+    NumberPrototypeImp(ExecState *exec,
+                       ObjectPrototypeImp *objProto,
+                       FunctionPrototypeImp *funcProto);
+  };
+
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * Number.prototype object
+   */
+  class NumberProtoFuncImp : public InternalFunctionImp {
+  public:
+    NumberProtoFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                       int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    enum { ToString, ToLocaleString, ValueOf };
+  private:
+    int id;
+  };
+
+  /**
+   * @internal
+   *
+   * The initial value of the the global variable's "Number" property
+   */
+  class NumberObjectImp : public InternalFunctionImp {
+  public:
+    NumberObjectImp(ExecState *exec,
+                    FunctionPrototypeImp *funcProto,
+                    NumberPrototypeImp *numberProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    Value get(ExecState *exec, const UString &p) const;
+    Value getValueProperty(ExecState *exec, int token) const;
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+    enum { NaNValue, NegInfinity, PosInfinity, MaxValue, MinValue };
+
     Completion execute(const List &);
     Object construct(const List &);
-  };
-
-  class NumberPrototype : public ObjectImp {
-  public:
-    NumberPrototype(const Object& proto);
-    virtual KJSO get(const UString &p) const;
   };
 

trunk/JavaScriptCore/kjs/object.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
+#include "value.h"
 #include "object.h"
-
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "types.h"
+#include "interpreter.h"
+#include "lookup.h"
+
+#include <assert.h>
+#include <math.h>
 #include <stdio.h>
-#include <string.h>
-#include <math.h>
-
-#include "kjs.h"
-#include "types.h"
+
 #include "internal.h"
+#include "collector.h"
 #include "operations.h"
-#include "collector.h"
 #include "error_object.h"
-
-namespace KJS {
-
-#ifdef WORDS_BIGENDIAN
-  unsigned char NaN_Bytes[] = { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 };
-  unsigned char Inf_Bytes[] = { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 };
-#elif defined(arm)
-  unsigned char NaN_Bytes[] = { 0, 0, 0xf8, 0x7f, 0, 0, 0, 0 };
-  unsigned char Inf_Bytes[] = { 0, 0, 0xf0, 0x7f, 0, 0, 0, 0 };
-#else
-  unsigned char NaN_Bytes[] = { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f };
-  unsigned char Inf_Bytes[] = { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f };
-#endif
-
-  const double NaN = *(const double*) NaN_Bytes;
-  const double Inf = *(const double*) Inf_Bytes;
-  const double D16 = 65536.0;
-  const double D31 = 2147483648.0;      /* TODO: remove in next version */
-  const double D32 = 4294967296.0;
-
-  // TODO: -0
-};
+#include "nodes.h"
+#include "property_map.h"
 
 using namespace KJS;
 
-const TypeInfo Imp::info = { "Imp", AbstractType, 0, 0, 0 };
-
-namespace KJS {
-  struct Property {
-    UString name;
-    Imp *object;
-    int attribute;
-    Property *next;
-  };
-}
-
-KJSO::KJSO()
-  : rep(0)
-{
-#ifdef KJS_DEBUG_MEM
-  count++;
-#endif
-}
-
-KJSO::KJSO(Imp *d)
-  : rep(d)
-{
-#ifdef KJS_DEBUG_MEM
-  count++;
-#endif
-
-  if (rep) {
-    rep->ref();
-    rep->setGcAllowed(true);
-  }
-}
-
-KJSO::KJSO(const KJSO &o)
-{
-#ifdef KJS_DEBUG_MEM
-  count++;
-#endif
-
-  rep = o.rep;
-  if (rep) {
-    rep->ref();
-    rep->setGcAllowed(true);
-  }
-}
-
-KJSO& KJSO::operator=(const KJSO &o)
-{
-  if (rep)
-    rep->deref();
-  rep = o.rep;
-  if (rep) {
-    rep->ref();
-    rep->setGcAllowed(true);
-  }
-
+// ------------------------------ Object ---------------------------------------
+
+Object::Object() : Value()
+{
+}
+
+Object::Object(ObjectImp *v) : Value(v)
+{
+}
+
+Object::Object(const Object &v) : Value(v)
+{
+}
+
+Object::~Object()
+{
+}
+
+Object& Object::operator=(const Object &v)
+{
+  Value::operator=(v);
   return *this;
 }
 
-KJSO::~KJSO()
-{
-#ifdef KJS_DEBUG_MEM
-  count--;
-#endif
-
-  if (rep)
-    rep->deref();
-}
-
-bool KJSO::isDefined() const
-{
-  return !isA(UndefinedType);
-}
-
-bool KJSO::isNull() const
-{
-  return !rep;
-}
-
-Type KJSO::type() const
-{
-#ifdef KJS_VERBOSE
-  if (!rep)
-    fprintf(stderr, "requesting type of null object\n");
-#endif
-
-  return rep ? rep->typeInfo()->type : UndefinedType;
-}
-
-bool KJSO::isObject() const
-{
-  return (type() >= ObjectType);
-}
-
-bool KJSO::isA(const char *s) const
-{
-  assert(rep);
-  const TypeInfo *info = rep->typeInfo();
-
-  if (!s || !info || !info->name)
+const ClassInfo *Object::classInfo() const
+{
+  return static_cast<ObjectImp*>(rep)->classInfo();
+}
+
+bool Object::inherits(const ClassInfo *cinfo) const
+{
+  return static_cast<ObjectImp*>(rep)->inherits(cinfo);
+}
+
+Object Object::dynamicCast(const Value &v)
+{
+  if (v.isNull() || v.type() != ObjectType)
+    return Object(0);
+
+  return Object(static_cast<ObjectImp*>(v.imp()));
+}
+
+Value Object::prototype() const
+{
+  return Value(static_cast<ObjectImp*>(rep)->prototype());
+}
+
+UString Object::className() const
+{
+  return static_cast<ObjectImp*>(rep)->className();
+}
+
+Value Object::get(ExecState *exec, const UString &propertyName) const
+{
+  return static_cast<ObjectImp*>(rep)->get(exec,propertyName);
+}
+
+void Object::put(ExecState *exec, const UString &propertyName, const Value &value, int attr)
+{
+  static_cast<ObjectImp*>(rep)->put(exec,propertyName,value,attr);
+}
+
+bool Object::canPut(ExecState *exec, const UString &propertyName) const
+{
+  return static_cast<ObjectImp*>(rep)->canPut(exec,propertyName);
+}
+
+bool Object::hasProperty(ExecState *exec, const UString &propertyName, bool recursive) const
+{
+  return static_cast<ObjectImp*>(rep)->hasProperty(exec,propertyName,recursive);
+}
+
+bool Object::deleteProperty(ExecState *exec, const UString &propertyName)
+{
+  return static_cast<ObjectImp*>(rep)->deleteProperty(exec,propertyName);
+}
+
+Value Object::defaultValue(ExecState *exec, Type hint) const
+{
+  return static_cast<ObjectImp*>(rep)->defaultValue(exec,hint);
+}
+
+bool Object::implementsConstruct() const
+{
+  return static_cast<ObjectImp*>(rep)->implementsConstruct();
+}
+
+Object Object::construct(ExecState *exec, const List &args)
+{
+  return static_cast<ObjectImp*>(rep)->construct(exec,args);
+}
+
+bool Object::implementsCall() const
+{
+  return static_cast<ObjectImp*>(rep)->implementsCall();
+}
+
+Value Object::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  return static_cast<ObjectImp*>(rep)->call(exec,thisObj,args);
+}
+
+bool Object::implementsHasInstance() const
+{
+  return static_cast<ObjectImp*>(rep)->implementsHasInstance();
+}
+
+Boolean Object::hasInstance(ExecState *exec, const Value &value)
+{
+  return static_cast<ObjectImp*>(rep)->hasInstance(exec,value);
+}
+
+const List Object::scope() const
+{
+  return static_cast<ObjectImp*>(rep)->scope();
+}
+
+void Object::setScope(const List &s)
+{
+  static_cast<ObjectImp*>(rep)->setScope(s);
+}
+
+List Object::propList(ExecState *exec, bool recursive)
+{
+  return static_cast<ObjectImp*>(rep)->propList(exec,recursive);
+}
+
+Value Object::internalValue() const
+{
+  return static_cast<ObjectImp*>(rep)->internalValue();
+}
+
+void Object::setInternalValue(const Value &v)
+{
+  static_cast<ObjectImp*>(rep)->setInternalValue(v);
+}
+
+// ------------------------------ ObjectImp ------------------------------------
+
+ObjectImp::ObjectImp(const Object &proto)
+  : _prop(0), _proto(static_cast<ObjectImp*>(proto.imp())), _internalValue(0L), _scope(0)
+{
+  //fprintf(stderr,"ObjectImp::ObjectImp %p %s\n",(void*)this);
+  _scope = ListImp::empty();
+  _prop = new PropertyMap();
+}
+
+ObjectImp::ObjectImp()
+{
+  //fprintf(stderr,"ObjectImp::ObjectImp %p %s\n",(void*)this);
+  _prop = 0;
+  _proto = NullImp::staticNull;
+  _internalValue = 0L;
+  _scope = ListImp::empty();
+  _prop = new PropertyMap();
+}
+
+ObjectImp::~ObjectImp()
+{
+  //fprintf(stderr,"ObjectImp::~ObjectImp %p\n",(void*)this);
+  if (_proto)
+    _proto->setGcAllowed();
+  if (_internalValue)
+    _internalValue->setGcAllowed();
+  if (_scope)
+    _scope->setGcAllowed();
+  delete _prop;
+}
+
+void ObjectImp::mark()
+{
+  //fprintf(stderr,"ObjectImp::mark() %p\n",(void*)this);
+  ValueImp::mark();
+
+  if (_proto && !_proto->marked())
+    _proto->mark();
+
+  PropertyMapNode *node = _prop->first();
+  while (node) {
+    if (!node->value->marked())
+      node->value->mark();
+    node = node->next();
+  }
+
+  if (_internalValue && !_internalValue->marked())
+    _internalValue->mark();
+  if (_scope && !_scope->marked())
+    _scope->mark();
+}
+
+const ClassInfo *ObjectImp::classInfo() const
+{
+  return 0;
+}
+
+bool ObjectImp::inherits(const ClassInfo *info) const
+{
+  if (!info)
     return false;
 
-  if (info->type == HostType && strcmp(s, "HostObject") == 0)
-    return true;
-
-  return (strcmp(s, info->name) == 0);
-}
-
-bool KJSO::derivedFrom(const char *s) const
-{
-  if (!s)
+  const ClassInfo *ci = classInfo();
+  if (!ci)
     return false;
 
-  assert(rep);
-  const TypeInfo *info = rep->typeInfo();
-  while (info) {
-    if (info->name && strcmp(s, info->name) == 0)
-      return true;
-    info = info->base;
-  }
-
-  return false;
-}
-
-KJSO KJSO::toPrimitive(Type preferred) const
-{
-  assert(rep);
-  return rep->toPrimitive(preferred);
-}
-
-Boolean KJSO::toBoolean() const
-{
-  assert(rep);
-  return rep->toBoolean();
-}
-
-Number KJSO::toNumber() const
-{
-  assert(rep);
-  return rep->toNumber();
-}
-
-// helper function for toInteger, toInt32, toUInt32 and toUInt16
-double KJSO::round() const
-{
-  if (isA(UndefinedType)) /* TODO: see below */
-    return 0.0;
-  Number n = toNumber();
-  if (n.value() == 0.0)   /* TODO: -0, NaN, Inf */
-    return 0.0;
-  double d = floor(fabs(n.value()));
-  if (n.value() < 0)
-    d *= -1;
-
-  return d;
-}
-
-// ECMA 9.4
-Number KJSO::toInteger() const
-{
-  return Number(round());
-}
-
-// ECMA 9.5
-int KJSO::toInt32() const
-{
-  double d = round();
-  double d32 = fmod(d, D32);
-
-  if (d32 >= D32 / 2.0)
-    d32 -= D32;
-
-  return static_cast<int>(d32);
-}
-
-// ECMA 9.6
-unsigned int KJSO::toUInt32() const
-{
-  double d = round();
-  double d32 = fmod(d, D32);
-
-  return static_cast<unsigned int>(d32);
-}
-
-// ECMA 9.7
-unsigned short KJSO::toUInt16() const
-{
-  double d = round();
-  double d16 = fmod(d, D16);
-
-  return static_cast<unsigned short>(d16);
-}
-
-String KJSO::toString() const
-{
-  assert(rep);
-  return rep->toString();
-}
-
-Object KJSO::toObject() const
-{
-  assert(rep);
-  if (isObject())
-    return Object(rep);
-
-  return rep->toObject();
-}
-
-bool KJSO::implementsCall() const
-{
-  return (type() == FunctionType ||
-          type() == InternalFunctionType ||
-          type() == ConstructorType ||
-          type() == DeclaredFunctionType ||
-          type() == AnonymousFunctionType);
-}
-
-// [[call]]
-KJSO KJSO::executeCall(const KJSO &thisV, const List *args)
-{
-  assert(rep);
-  assert(implementsCall());
-  return (static_cast<FunctionImp*>(rep))->executeCall(thisV.imp(), args);
-}
-
-KJSO KJSO::executeCall(const KJSO &thisV, const List *args, const List *extraScope) const
-{
-  assert(rep);
-  assert(implementsCall());
-  return (static_cast<FunctionImp*>(rep))->executeCall(thisV.imp(), args, extraScope);
-}
-
-void KJSO::setConstructor(KJSO c)
-{
-  put("constructor", c, DontEnum | DontDelete | ReadOnly);
-}
-
-// ECMA 8.7.1
-KJSO KJSO::getBase() const
-{
-  if (!isA(ReferenceType))
-    return Error::create(ReferenceError, I18N_NOOP("Invalid reference base"));
-
-  return ((ReferenceImp*)rep)->getBase();
-}
-
-// ECMA 8.7.2
-UString KJSO::getPropertyName() const
-{
-  if (!isA(ReferenceType))
-    // the spec wants a runtime error here. But getValue() and putValue()
-    // will catch this case on their own earlier. When returning a Null
-    // string we should be on the safe side.
-    return UString();
-
-  return ((ReferenceImp*)rep)->getPropertyName();
-}
-
-// ECMA 8.7.1
-KJSO KJSO::getValue() const
-{
-  if (!isA(ReferenceType)) {
-    return *this;
-  }
-  KJSO o = getBase();
-  if (o.isNull() || o.isA(NullType)) {
-    UString m = I18N_NOOP("Can't find variable: ") + getPropertyName();
-    return Error::create(ReferenceError, m.ascii());
-  }
-
-  return o.get(getPropertyName());
-}
-
-/* TODO: remove in next version */
-KJSO KJSO::getValue()
-{
-    return const_cast<const KJSO*>(this)->getValue();
-}
-
-// ECMA 8.7.2
-ErrorType KJSO::putValue(const KJSO& v)
-{
-  if (!isA(ReferenceType))
-    return ReferenceError;
-
-  KJSO o = getBase();
-  if (o.isA(NullType))
-    Global::current().put(getPropertyName(), v);
-  else {
-    // are we writing into an array ?
-    if (o.isA(ObjectType) && (o.toObject().getClass() == ArrayClass))
-      o.putArrayElement(getPropertyName(), v);
+  while (ci && ci != info)
+    ci = ci->parentClass;
+
+  return (ci == info);
+}
+
+Type ObjectImp::type() const
+{
+  return ObjectType;
+}
+
+Value ObjectImp::prototype() const
+{
+  return Value(_proto);
+}
+
+void ObjectImp::setPrototype(const Value &proto)
+{
+  _proto = proto.imp();
+}
+
+UString ObjectImp::className() const
+{
+  const ClassInfo *ci = classInfo();
+  if ( ci )
+    return ci->className;
+  return "Object";
+}
+
+Value ObjectImp::get(ExecState *exec, const UString &propertyName) const
+{
+  if (propertyName == "__proto__") {
+    Object proto = Object::dynamicCast(prototype());
+    // non-standard netscape extension
+    if (proto.isNull())
+      return Null();
     else
-      o.put(getPropertyName(), v);
-  }
-
-  return NoError;
-}
-
-void KJSO::setPrototype(const KJSO& p)
-{
-  assert(rep);
-  rep->setPrototype(p);
-}
-
-void KJSO::setPrototypeProperty(const KJSO& p)
-{
-  assert(rep);
-  put("prototype", p, DontEnum | DontDelete | ReadOnly);
-}
-
-KJSO KJSO::prototype() const
-{
-  if (rep)
-    return KJSO(rep->proto);
-  else
-    return KJSO();
-}
-
-// ECMA 8.6.2.1
-KJSO KJSO::get(const UString &p) const
-{
-  assert(rep);
-  return rep->get(p);
+      return proto;
+  }
+
+  ValueImp *imp = getDirect(propertyName);
+  if ( imp )
+    return Value(imp);
+
+  Object proto = Object::dynamicCast(prototype());
+  if (proto.isNull())
+    return Undefined();
+
+  return proto.get(exec,propertyName);
+}
+
+// This get method only looks at the property map.
+// A bit like hasProperty(recursive=false), this doesn't go to the prototype.
+// This is used e.g. by lookupOrCreateFunction (to cache a function, we don't want
+// to look up in the prototype, it might already exist there)
+ValueImp* ObjectImp::getDirect(const UString& propertyName) const
+{
+  return _prop->get(propertyName);
 }
 
 // ECMA 8.6.2.2
-void KJSO::put(const UString &p, const KJSO& v)
-{
-  assert(rep);
-  rep->put(p, v);
-}
-
-// ECMA 8.6.2.2
-void KJSO::put(const UString &p, const KJSO& v, int attr)
-{
-  static_cast<Imp*>(rep)->put(p, v, attr);
-}
-
-// provided for convenience.
-void KJSO::put(const UString &p, double d, int attr)
-{
-  put(p, Number(d), attr);
-}
-
-// provided for convenience.
-void KJSO::put(const UString &p, int i, int attr)
-{
-  put(p, Number(i), attr);
-}
-
-// provided for convenience.
-void KJSO::put(const UString &p, unsigned int u, int attr)
-{
-  put(p, Number(u), attr);
-}
-
-// ECMA 15.4.5.1
-void KJSO::putArrayElement(const UString &p, const KJSO& v)
-{
-  assert(rep);
-  rep->putArrayElement(p, v);
-}
-
-// ECMA 8.6.2.3
-bool KJSO::canPut(const UString &p) const
-{
-  assert(rep);
-  return rep->canPut(p);
-}
-
-// ECMA 8.6.2.4
-bool KJSO::hasProperty(const UString &p, bool recursive) const
-{
-  assert(rep);
-  return rep->hasProperty(p, recursive);
-}
-
-// ECMA 8.6.2.5
-bool KJSO::deleteProperty(const UString &p)
-{
-  assert(rep);
-  return rep->deleteProperty(p);
-}
-
-Object::Object(Imp *d) : KJSO(d) { }
-
-Object::Object(Class c) : KJSO(new ObjectImp(c)) { }
-
-Object::Object(Class c, const KJSO& v) : KJSO(new ObjectImp(c, v)) { }
-
-Object::Object(Class c, const KJSO& v, const Object& p)
-  : KJSO(new ObjectImp(c, v))
-{
-  setPrototype(p);
-}
-
-Object::~Object() { }
-
-void Object::setClass(Class c)
-{
-  static_cast<ObjectImp*>(rep)->cl = c;
-}
-
-Class Object::getClass() const
-{
-  assert(rep);
-  return static_cast<ObjectImp*>(rep)->cl;
-}
-
-void Object::setInternalValue(const KJSO& v)
-{
-  assert(rep);
-  static_cast<ObjectImp*>(rep)->val = v.imp();
-}
-
-KJSO Object::internalValue()
-{
-  assert(rep);
-  return KJSO(static_cast<ObjectImp*>(rep)->val);
-}
-
-Object Object::create(Class c)
-{
-  return Object::create(c, KJSO());
-}
-
-// factory
-Object Object::create(Class c, const KJSO& val)
-{
-  Global global(Global::current());
-  Object obj = Object();
-  obj.setClass(c);
-  obj.setInternalValue(val);
-
-  UString p = "[[";
-  switch (c) {
-  case UndefClass:
-  case ObjectClass:
-    p += "Object";
-    break;
-  case FunctionClass:
-    p += "Function";
-    break;
-  case ArrayClass:
-    p += "Array";
-    obj.put("length", Number(0), DontEnum | DontDelete);
-    break;
-  case StringClass:
-    p += "String";
-    obj.put("length", val.toString().value().size());
-    break;
-  case BooleanClass:
-    p += "Boolean";
-    break;
-  case NumberClass:
-    p += "Number";
-    break;
-  case DateClass:
-    p += "Date";
-    break;
-  case RegExpClass:
-    p += "RegExp";
-    break;
-  case ErrorClass:
-    p += "Error";
-    break;
-  }
-  p += ".prototype]]";
-
-  //  KJSO prot = global.get(p).get("prototype");
-  KJSO prot = global.get(p);
-  assert(prot.isDefined());
-
-  obj.setPrototype(prot);
-  return obj;
-}
-
-Object Object::create(Class c, const KJSO& val, const Object& p)
-{
-  Global global(Global::current());
-  Object obj = Object();
-  Object prot;
-  obj.setClass(c);
-  obj.setInternalValue(val);
-
-  prot = p;
-  obj.setPrototype(prot);
-  return obj;
-}
-
-Object Object::dynamicCast(const KJSO &obj)
-{
-  // return null object on type mismatch
-  if (!obj.isA(ObjectType))
-    return Object(0L);
-
-  return Object(obj.imp());
-
-}
-
-#ifdef KJS_DEBUG_MEM
-int KJSO::count = 0;
-int Imp::count = 0;
-int List::count = 0;
-#endif
-
-Imp::Imp()
-  : refcount(0), prop(0), proto(0)
-{
-  setCreated(true);
-#ifdef KJS_DEBUG_MEM
-  count++;
-#endif
-}
-
-Imp::~Imp()
-{
-#ifdef KJS_DEBUG_MEM
-  assert(Collector::collecting);
-  count--;
-#endif
-
-// dangling pointer during garbage collection !
-//   if (proto)
-//     proto->deref();
-
-  // delete attached properties
-  Property *tmp, *p = prop;
-  while (p) {
-    tmp = p;
-    p = p->next;
-    delete tmp;
-  }
-}
-
-KJSO Imp::toPrimitive(Type preferred) const
-{
-  return defaultValue(preferred);
-  /* TODO: is there still any need to throw a runtime error _here_ ? */
-}
-
-Boolean Imp::toBoolean() const
-{
-  return Boolean();
-}
-
-Number Imp::toNumber() const
-{
-  return Number();
-}
-
-String Imp::toString() const
-{
-  return String();
-}
-
-Object Imp::toObject() const
-{
-  return Object(Error::create(TypeError).imp());
-}
-
-
-PropList* Imp::propList(PropList *first, PropList *last, bool recursive) const
-{
-  Property *pr = prop;
-  while(pr) {
-    if (!(pr->attribute & DontEnum) && !first->contains(pr->name)) {
-      if(last) {
-        last->next = new PropList();
-        last = last->next;
-      } else {
-        first = new PropList();
-        last = first;
-      }
-      last->name = pr->name;
-    }
-    pr = pr->next;
-  }
-  if (proto && recursive)
-    proto->propList(first, last);
-
-  return first;
-}
-
-KJSO Imp::get(const UString &p) const
-{
-  Property *pr = prop;
-  while (pr) {
-    if (pr->name == p) {
-      return pr->object;
-    }
-    pr = pr->next;
-  }
-
-  if (!proto)
-    return Undefined();
-
-  return proto->get(p);
-}
-
-// may be overriden
-void Imp::put(const UString &p, const KJSO& v)
-{
-  put(p, v, None);
-}
-
-// ECMA 8.6.2.2
-void Imp::put(const UString &p, const KJSO& v, int attr)
-{
+void ObjectImp::put(ExecState *exec, const UString &propertyName,
+                     const Value &value, int attr)
+{
+  assert(!value.isNull());
+  assert(value.type() != ReferenceType);
+  assert(value.type() != CompletionType);
+  assert(value.type() != ListType);
+
   /* TODO: check for write permissions directly w/o this call */
+  /* Doesn't look very easy with the PropertyMap API - David */
   // putValue() is used for JS assignemnts. It passes no attribute.
   // Assume that a C++ implementation knows what it is doing
   // and let it override the canPut() check.
-  if (attr == None && !canPut(p))
+  if ((attr == None || attr == DontDelete) && !canPut(exec,propertyName)) {
+#ifdef KJS_VERBOSE
+    fprintf( stderr, "WARNING: canPut %s said NO\n", propertyName.ascii() );
+#endif
     return;
-
-  Property *pr;
-
-  if (prop) {
-    pr = prop;
-    while (pr) {
-      if (pr->name == p) {
-        // replace old value
-        pr->object = v.imp();
-        pr->attribute = attr;
-        return;
+  }
+
+  if (propertyName == "__proto__") {
+    // non-standard netscape extension
+    setPrototype(value);
+    return;
+  }
+
+  _prop->put(propertyName,value.imp(),attr);
+}
+
+// ECMA 8.6.2.3
+bool ObjectImp::canPut(ExecState *, const UString &propertyName) const
+{
+  PropertyMapNode *node = _prop->getNode(propertyName);
+  if (node)
+    return!(node->attr & ReadOnly);
+
+  // Look in the static hashtable of properties
+  const HashEntry* e = findPropertyHashEntry(propertyName);
+  if (e)
+    return !(e->attr & ReadOnly);
+
+  // Don't look in the prototype here. We can always put an override
+  // in the object, even if the prototype has a ReadOnly property.
+  return true;
+}
+
+// ECMA 8.6.2.4
+bool ObjectImp::hasProperty(ExecState *exec, const UString &propertyName, bool recursive) const
+{
+  if (propertyName == "__proto__")
+    return true;
+  if (_prop->get(propertyName))
+    return true;
+
+  // Look in the static hashtable of properties
+  if (findPropertyHashEntry(propertyName))
+      return true;
+
+  // Look in the prototype
+  Object proto = Object::dynamicCast(prototype());
+  if (proto.isNull() || !recursive)
+    return false;
+
+  return proto.hasProperty(exec,propertyName);
+}
+
+// ECMA 8.6.2.5
+bool ObjectImp::deleteProperty(ExecState */*exec*/, const UString &propertyName)
+{
+  PropertyMapNode *node = _prop->getNode(propertyName);
+  if (node) {
+    if ((node->attr & DontDelete))
+      return false;
+    _prop->remove(propertyName);
+    return true;
+  }
+
+  // Look in the static hashtable of properties
+  if (findPropertyHashEntry(propertyName))
+    return false; // No builtin property can be deleted
+  return true;
+}
+
+void ObjectImp::deleteAllProperties( ExecState * )
+{
+  _prop->clear();
+}
+
+// ECMA 8.6.2.6
+Value ObjectImp::defaultValue(ExecState *exec, Type hint) const
+{
+  if (hint != StringType && hint != NumberType) {
+    /* Prefer String for Date objects */
+    if (_proto == exec->interpreter()->builtinDatePrototype().imp())
+      hint = StringType;
+    else
+      hint = NumberType;
+  }
+
+  Value v;
+  if (hint == StringType)
+    v = get(exec,"toString");
+  else
+    v = get(exec,"valueOf");
+
+  if (v.type() == ObjectType) {
+    Object o = Object(static_cast<ObjectImp*>(v.imp()));
+    if (o.implementsCall()) { // spec says "not primitive type" but ...
+      Object thisObj = Object(const_cast<ObjectImp*>(this));
+      Value def = o.call(exec,thisObj,List::empty());
+      Type defType = def.type();
+      if (defType == UnspecifiedType || defType == UndefinedType ||
+          defType == NullType || defType == BooleanType ||
+          defType == StringType || defType == NumberType) {
+        return def;
       }
-      pr = pr->next;
     }
   }
 
-  // add new property
-  pr = new Property;
-  pr->name = p;
-  pr->object = v.imp();
-  pr->attribute = attr;
-  pr->next = prop;
-  prop = pr;
-}
-
-// ECMA 8.6.2.3
-bool Imp::canPut(const UString &p) const
-{
-  if (prop) {
-    const Property *pr = prop;
-    while (pr) {
-      if (pr->name == p)
-        return !(pr->attribute & ReadOnly);
-      pr = pr->next;
+  if (hint == StringType)
+    v = get(exec,"valueOf");
+  else
+    v = get(exec,"toString");
+
+  if (v.type() == ObjectType) {
+    Object o = Object(static_cast<ObjectImp*>(v.imp()));
+    if (o.implementsCall()) { // spec says "not primitive type" but ...
+      Object thisObj = Object(const_cast<ObjectImp*>(this));
+      Value def = o.call(exec,thisObj,List::empty());
+      Type defType = def.type();
+      if (defType == UnspecifiedType || defType == UndefinedType ||
+          defType == NullType || defType == BooleanType ||
+          defType == StringType || defType == NumberType) {
+        return def;
+      }
     }
   }
-  if (!proto)
-    return true;
-
-  return proto->canPut(p);
-}
-
-// ECMA 8.6.2.4
-bool Imp::hasProperty(const UString &p, bool recursive) const
-{
-  const Property *pr = prop;
-  while (pr) {
-    if (pr->name == p)
-      return true;
-    pr = pr->next;
-  }
-
-  if (!proto || !recursive)
-    return false;
-
-  return proto->hasProperty(p);
-}
-
-// ECMA 8.6.2.5
-bool Imp::deleteProperty(const UString &p)
-{
-  Property *pr = prop;
-  Property **prev = &prop;
-  while (pr) {
-    if (pr->name == p) {
-      if ((pr->attribute & DontDelete))
-        return false;
-      *prev = pr->next;
-      delete pr;
-      return true;
+
+  Object err = Error::create(exec, TypeError, I18N_NOOP("No default value"));
+  exec->setException(err);
+  return err;
+}
+
+const HashEntry* ObjectImp::findPropertyHashEntry( const UString& propertyName ) const
+{
+  const ClassInfo *info = classInfo();
+  while (info) {
+    if (info->propHashTable) {
+      const HashEntry *e = Lookup::findEntry(info->propHashTable, propertyName);
+      if (e)
+        return e;
     }
-    prev = &(pr->next);
-    pr = pr->next;
-  }
+    info = info->parentClass;
+  }
+  return 0L;
+}
+
+bool ObjectImp::implementsConstruct() const
+{
+  return false;
+}
+
+Object ObjectImp::construct(ExecState */*exec*/, const List &/*args*/)
+{
+  assert(false);
+  return Object(0);
+}
+
+bool ObjectImp::implementsCall() const
+{
+  return false;
+}
+
+Value ObjectImp::call(ExecState */*exec*/, Object &/*thisObj*/, const List &/*args*/)
+{
+  assert(false);
+  return Object(0);
+}
+
+bool ObjectImp::implementsHasInstance() const
+{
+  return false;
+}
+
+Boolean ObjectImp::hasInstance(ExecState */*exec*/, const Value &/*value*/)
+{
+  assert(false);
+  return Boolean(false);
+}
+
+const List ObjectImp::scope() const
+{
+  return _scope;
+}
+
+void ObjectImp::setScope(const List &s)
+{
+  if (_scope) _scope->setGcAllowed();
+  _scope = static_cast<ListImp*>(s.imp());
+}
+
+List ObjectImp::propList(ExecState *exec, bool recursive)
+{
+  List list;
+  if (_proto && _proto->type() == ObjectType && recursive)
+    list = static_cast<ObjectImp*>(_proto)->propList(exec,recursive);
+
+
+  PropertyMapNode *node = _prop->first();
+  while (node) {
+    if (!(node->attr & DontEnum))
+      list.append(Reference(Object(this), node->name));
+    node = node->next();
+  }
+
+  // Add properties from the static hashtable of properties
+  const ClassInfo *info = classInfo();
+  while (info) {
+    if (info->propHashTable) {
+      int size = info->propHashTable->size;
+      const HashEntry *e = info->propHashTable->entries;
+      for (int i = 0; i < size; ++i, ++e) {
+        if ( e->s && !(e->attr & DontEnum) )
+          list.append(Reference(Object(this), e->s)); /// ######### check for duplicates with the propertymap
+      }
+    }
+    info = info->parentClass;
+  }
+
+  return list;
+}
+
+Value ObjectImp::internalValue() const
+{
+  return Value(_internalValue);
+}
+
+void ObjectImp::setInternalValue(const Value &v)
+{
+  _internalValue = v.imp();
+}
+
+// The following functions simply call the corresponding functions in ValueImp
+// but are overridden in case of future needs
+
+Value ObjectImp::toPrimitive(ExecState *exec, Type preferredType) const
+{
+  return defaultValue(exec,preferredType);
+}
+
+bool ObjectImp::toBoolean(ExecState */*exec*/) const
+{
   return true;
 }
 
-// ECMA 15.4.5.1
-void Imp::putArrayElement(const UString &p, const KJSO& v)
-{
-  if (!canPut(p))
-    return;
-
-  if (hasProperty(p)) {
-    if (p == "length") {
-      KJSO len = get("length");
-      unsigned int oldLen = len.toUInt32();
-      unsigned int newLen = v.toUInt32();
-      // shrink array
-      for (unsigned int u = newLen; u < oldLen; u++) {
-        UString p = UString::from(u);
-        if (hasProperty(p, false))
-          deleteProperty(p);
-      }
-      put("length", Number(newLen), DontEnum | DontDelete);
-      return;
-    }
-    //    put(p, v);
-    } //  } else
-    put(p, v);
-
-  // array index ?
-  unsigned int idx;
-  if (!sscanf(p.cstring().c_str(), "%u", &idx)) /* TODO */
-    return;
-
-  // do we need to update/create the length property ?
-  if (hasProperty("length", false)) {
-    KJSO len = get("length");
-    if (idx < len.toUInt32())
-      return;
-  }
-
-  put("length", Number(idx+1), DontDelete | DontEnum);
-}
-
-bool Imp::implementsCall() const
-{
-  return (type() == FunctionType ||
-          type() == InternalFunctionType ||
-          type() == ConstructorType ||
-          type() == DeclaredFunctionType ||
-          type() == AnonymousFunctionType);
-}
-
-// ECMA 8.6.2.6 (new draft)
-KJSO Imp::defaultValue(Type hint) const
-{
-  KJSO o;
-
-  /* TODO String on Date object */
-  if (hint != StringType && hint != NumberType)
-    hint = NumberType;
-
-  if (hint == StringType)
-    o = get("toString");
-  else
-    o = get("valueOf");
-
-  Imp *that = const_cast<Imp*>(this);
-  if (o.implementsCall()) { // spec says "not primitive type" but ...
-    FunctionImp *f = static_cast<FunctionImp*>(o.imp());
-    KJSO s = f->executeCall(that, 0L);
-    if (!s.isObject())
-      return s;
-  }
-
-  if (hint == StringType)
-    o = get("valueOf");
-  else
-    o = get("toString");
-
-  if (o.implementsCall()) {
-    FunctionImp *f = static_cast<FunctionImp*>(o.imp());
-    KJSO s = f->executeCall(that, 0L);
-    if (!s.isObject())
-      return s;
-  }
-
-  return Error::create(TypeError, I18N_NOOP("No default value"));
-}
-
-void Imp::mark(Imp*)
-{
-  setMarked(true);
-
-  if (proto && !proto->marked())
-    proto->mark();
-
-  struct Property *p = prop;
-  while (p) {
-    if (p->object && !p->object->marked())
-      p->object->mark();
-    p = p->next;
-  }
-}
-
-bool Imp::marked() const
-{
-  return prev;
-}
-
-void Imp::setPrototype(const KJSO& p)
-{
-  if (proto)
-    proto->deref();
-  proto = p.imp();
-  if (proto)
-    proto->ref();
-}
-
-void Imp::setPrototypeProperty(const KJSO &p)
-{
-  put("prototype", p, DontEnum | DontDelete | ReadOnly);
-}
-
-void Imp::setConstructor(const KJSO& c)
-{
-  put("constructor", c, DontEnum | DontDelete | ReadOnly);
-}
-
-void* Imp::operator new(size_t s)
-{
-  return Collector::allocate(s);
-}
-
-void Imp::operator delete(void*, size_t)
-{
-  // deprecated. a mistake.
-}
-
-void Imp::operator delete(void*)
-{
-  // Do nothing. So far.
-}
-
-void Imp::setMarked(bool m)
-{
-  prev = m ? this : 0L;
-}
-
-void Imp::setGcAllowed(bool a)
-{
-  next = this;
-  if (a)
-    next++;
-}
-
-bool Imp::gcAllowed() const
-{
-  return (next && next != this);
-}
-
-void Imp::setCreated(bool c)
-{
-  next = c ? this : 0L;
-}
-
-bool Imp::created() const
-{
-  return next;
-}
-
-ObjectImp::ObjectImp(Class c) : cl(c), val(0L) { }
-
-ObjectImp::ObjectImp(Class c, const KJSO &v) : cl(c), val(v.imp()) { }
-
-ObjectImp::ObjectImp(Class c, const KJSO &v, const KJSO &p)
-  : cl(c), val(v.imp())
-{
-  setPrototype(p);
-}
-
-ObjectImp::~ObjectImp() { }
-
-Boolean ObjectImp::toBoolean() const
-{
-  return Boolean(true);
-}
-
-Number ObjectImp::toNumber() const
-{
-  return toPrimitive(NumberType).toNumber();
-}
-
-String ObjectImp::toString() const
-{
-  KJSO tmp;
-  String res;
-
-  if (hasProperty("toString") && (tmp = get("toString")).implementsCall()) {
-    // TODO live w/o hack
-    res = tmp.executeCall(KJSO(const_cast<ObjectImp*>(this)), 0L).toString();
-  } else {
-    tmp = toPrimitive(StringType);
-    res = tmp.toString();
-  }
-
-  return res;
-}
-
-const TypeInfo ObjectImp::info = { "Object", ObjectType, 0, 0, 0 };
-
-Object ObjectImp::toObject() const
+double ObjectImp::toNumber(ExecState *exec) const
+{
+  Value prim = toPrimitive(exec,NumberType);
+  if (exec->hadException()) // should be picked up soon in nodes.cpp
+    return 0.0;
+  return prim.toNumber(exec);
+}
+
+int ObjectImp::toInteger(ExecState *exec) const
+{
+  return ValueImp::toInteger(exec);
+}
+
+int ObjectImp::toInt32(ExecState *exec) const
+{
+  return ValueImp::toInt32(exec);
+}
+
+unsigned int ObjectImp::toUInt32(ExecState *exec) const
+{
+  return ValueImp::toUInt32(exec);
+}
+
+unsigned short ObjectImp::toUInt16(ExecState *exec) const
+{
+  return ValueImp::toUInt16(exec);
+}
+
+UString ObjectImp::toString(ExecState *exec) const
+{
+  Value prim = toPrimitive(exec,StringType);
+  if (exec->hadException()) // should be picked up soon in nodes.cpp
+    return "";
+  return prim.toString(exec);
+}
+
+Object ObjectImp::toObject(ExecState */*exec*/) const
 {
   return Object(const_cast<ObjectImp*>(this));
 }
 
-KJSO ObjectImp::toPrimitive(Type preferred) const
-{
-  // ### Imp already does that now. Remove in KDE 3.0.
-  return defaultValue(preferred);
-  /* TODO: is there still any need to throw a runtime error _here_ ? */
-}
-
-void ObjectImp::mark(Imp*)
-{
-  // mark objects from the base
-  Imp::mark();
-
-  // mark internal value, if any and it has not been visited yet
-  if (val && !val->marked())
-    val->mark();
-}
-
-HostImp::HostImp()
-{
-    setPrototype(Global::current().objectPrototype());
-    //printf("HostImp::HostImp() %p\n",this);
-}
-
-HostImp::~HostImp() { }
-
-Boolean HostImp::toBoolean() const
-{
-  return Boolean(true);
-}
-
-String HostImp::toString() const
-{
-  // Exact copy of ObjectImp::toString....
-  KJSO tmp;
-  String res;
-
-  if (hasProperty("toString") && (tmp = get("toString")).implementsCall()) {
-    // TODO live w/o hack
-    res = tmp.executeCall(KJSO(const_cast<HostImp*>(this)), 0L).toString();
-  } else {
-    tmp = toPrimitive(StringType);
-    res = tmp.toString();
-  }
-
-  return res;
-}
-
-const TypeInfo HostImp::info = { "HostObject", HostType, 0, 0, 0 };
-
-Object Error::createObject(ErrorType e, const char *m, int l)
-{
-  Context *context = Context::current();
-  if (!context)
-    return Object();
-
-  Object err = ErrorObject::create(e, m, l);
-
-  if (!KJScriptImp::hadException())
-    KJScriptImp::setException(err.imp());
-
-  const struct ErrorStruct {
-      ErrorType e;
-      const char *s;
-  } errtab[] = {
-      { GeneralError, I18N_NOOP("General error") },
-      { EvalError, I18N_NOOP("Evaluation error") },
-      { RangeError, I18N_NOOP("Range error") },
-      { ReferenceError, I18N_NOOP("Reference error") },
-      { SyntaxError, I18N_NOOP("Syntax error") },
-      { TypeError, I18N_NOOP("Type error") },
-      { URIError, I18N_NOOP("URI error") },
-      { (ErrorType)0, 0 }
-  };
-
-  const char *estr = I18N_NOOP("Unknown error");
-  const ErrorStruct *estruct = errtab;
-  while (estruct->e) {
-      if (estruct->e == e) {
-          estr = estruct->s;
-          break;
-      }
-      estruct++;
-  }
-
+
+// ------------------------------ Error ----------------------------------------
+
+const char * const errorNamesArr[] = {
+  I18N_NOOP("Error"), // GeneralError
+  I18N_NOOP("Evaluation error"), // EvalError
+  I18N_NOOP("Range error"), // RangeError
+  I18N_NOOP("Reference error"), // ReferenceError
+  I18N_NOOP("Syntax error"), // SyntaxError
+  I18N_NOOP("Type error"), // TypeError
+  I18N_NOOP("URI error"), // URIError
+};
+
+const char * const * const Error::errorNames = errorNamesArr;
+
+Object Error::create(ExecState *exec, ErrorType errtype, const char *message,
+                     int lineno, int sourceId)
+{
+  Object cons;
+
+  switch (errtype) {
+  case EvalError:
+    cons = exec->interpreter()->builtinEvalError();
+    break;
+  case RangeError:
+    cons = exec->interpreter()->builtinRangeError();
+    break;
+  case ReferenceError:
+    cons = exec->interpreter()->builtinReferenceError();
+    break;
+  case SyntaxError:
+    cons = exec->interpreter()->builtinSyntaxError();
+    break;
+  case TypeError:
+    cons = exec->interpreter()->builtinTypeError();
+    break;
+  case URIError:
+    cons = exec->interpreter()->builtinURIError();
+    break;
+  default:
+    cons = exec->interpreter()->builtinError();
+    break;
+  }
+
+  if (!message)
+    message = errorNames[errtype];
+  List args;
+  args.append(String(message));
+  Object err = Object::dynamicCast(cons.construct(exec,args));
+
+  if (lineno != -1)
+    err.put(exec, "line", Number(lineno));
+  if (sourceId != -1)
+    err.put(exec, "sourceId", Number(sourceId));
+
+  return err;
+
+/*
 #ifndef NDEBUG
   const char *msg = err.get("message").toString().value().ascii();
   if (l >= 0)
-      fprintf(stderr, "JS: %s at line %d. %s\n", estr, l, msg);
+      fprintf(stderr, "KJS: %s at line %d. %s\n", estr, l, msg);
   else
-      fprintf(stderr, "JS: %s. %s\n", estr, msg);
+      fprintf(stderr, "KJS: %s. %s\n", estr, msg);
 #endif
 
   return err;
-}
-
-KJSO Error::create(ErrorType e, const char *m, int l)
-{
-  return KJSO(createObject(e, m, l).imp());
-}
+*/
+}
+

trunk/JavaScriptCore/kjs/object.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
  *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
  */
+
 
 #ifndef _KJS_OBJECT_H_
 #define _KJS_OBJECT_H_
 
-#include <stdlib.h>
-
-#include "ustring.h"
-
-/**
- * @short Main namespace
- */
+// Objects
+
+#include "value.h"
+#include "types.h"
+
 namespace KJS {
 
+  class ObjectImpPrivate;
+  class PropertyMap;
+  class HashTable;
+  class HashEntry;
+  class ListImp;
+
+  // ECMA 262-3 8.6.1
+  // Attributes (only applicable to the Object type)
+  enum Attribute { None       = 0,
+                   ReadOnly   = 1 << 1, // property can be only read, not written
+                   DontEnum   = 1 << 2, // property doesn't appear in (for .. in ..)
+                   DontDelete = 1 << 3, // property can't be deleted
+                   Internal   = 1 << 4, // an internal property, set to by pass checks
+                   Function   = 1 << 5 }; // property is a function - only used by static hashtables
+
   /**
-   * Types of classes derived from KJSO
+   * Class Information
    */
-  enum Type { // main types
-              AbstractType = 1,
-              UndefinedType,
-              NullType,
-              BooleanType,
-              NumberType,
-              StringType,
-              ObjectType,
-              HostType,
-              ReferenceType,
-              CompletionType,
-              // extended types
-              FunctionType,
-              InternalFunctionType,
-              DeclaredFunctionType,
-              AnonymousFunctionType,
-              ConstructorType,
-              ActivationType
-  };
-
-  /**
-   * Property attributes.
-   */
-  enum Attribute { None       = 0,
-                   ReadOnly   = 1 << 1,
-                   DontEnum   = 1 << 2,
-                   DontDelete = 1 << 3,
-                   Internal   = 1 << 4 };
-
-  /**
-   * Types of classes derived from @ref Object.
-   */
-  enum Class { UndefClass,
-               ArrayClass,
-               StringClass,
-               BooleanClass,
-               NumberClass,
-               ObjectClass,
-               DateClass,
-               RegExpClass,
-               ErrorClass,
-               FunctionClass };
-
-  /**
-   * Completion types.
-   */
-  enum Compl { Normal, Break, Continue, ReturnValue, Throw };
-
-  /**
-   * Error codes.
-   */
-  enum ErrorType { NoError = 0,
-                   GeneralError,
-                   EvalError,
-                   RangeError,
-                   ReferenceError,
-                   SyntaxError,
-                   TypeError,
-                   URIError };
-
-  extern const double NaN;
-  extern const double Inf;
-
-  // forward declarations
-  class Imp;
-  class Boolean;
-  class Number;
-  class String;
-  class Object;
-  struct Property;
-  class PropList;
-  class List;
-
-  /**
-   * @short Type information.
-   */
-  struct TypeInfo {
-    /**
-     * A string denoting the type name. Example: "Number".
-     */
-    const char *name;
-    /**
-     * One of the @ref KJS::Type enums.
-     */
-    Type type;
-    /**
-     * Pointer to the type information of the base class.
-     * NULL if there is none.
-     */
-    const TypeInfo *base;
-    /**
-     * Additional specifier for your own use.
-     */
-    int extra;
-    /**
-     * Reserved for future extensions (internal).
+  struct ClassInfo {
+    /**
+     * A string denoting the class name. Example: "Window".
+     */
+    const char* className;
+    /**
+     * Pointer to the class information of the base class.
+     * 0L if there is none.
+     */
+    const ClassInfo *parentClass;
+    /**
+     * Static hash-table of properties.
+     */
+    const HashTable *propHashTable;
+    /**
+     * Reserved for future extension.
      */
     void *dummy;
@@ -135 +72 @@
 
   /**
-   * @short Main base class for every KJS object.
+   * Represents an Object. This is a wrapper for ObjectImp
    */
-  class KJSO {
-    friend class ElementNode;
+  class Object : public Value {
   public:
-    /**
-     * Constructor.
-     */
-    KJSO();
-    /**
-     * @internal
-     */
-    KJSO(Imp *d);
-    /**
-     * Copy constructor.
-     */
-    KJSO(const KJSO &);
-    /*
-     * Assignment operator
-     */
-    KJSO& operator=(const KJSO &);
-    /**
-     * Destructor.
-     */
-    virtual ~KJSO();
-    /**
-     * @return True if this object is null, i.e. if there is no data attached
-     * to this object. Don't confuse this with the Null object.
-     */
-    bool isNull() const;
-    /**
-     * @return True if this objects is of any other value than Undefined.
-     */
-    bool isDefined() const;
-    /**
-     * @return the type of the object. One of the @ref KJS::Type enums.
-     */
+    Object();
+    explicit Object(ObjectImp *v);
+    Object(const Object &v);
+    virtual ~Object();
+
+    Object& operator=(const Object &v);
+
+    virtual const ClassInfo *classInfo() const;
+    bool inherits(const ClassInfo *cinfo) const;
+
+    /**
+     * Converts a Value into an Object. If the value's type is not ObjectType,
+     * a null object will be returned (i.e. one with it's internal pointer set
+     * to 0). If you do not know for sure whether the value is of type
+     * ObjectType, you should check the @ref isNull() methods afterwards before
+     * calling any methods on the Object.
+     *
+     * @return The value converted to an object
+     */
+    static Object dynamicCast(const Value &v);
+
+    /**
+     * Returns the prototype of this object. Note that this is not the same as
+     * the "prototype" property.
+     *
+     * See ECMA 8.6.2
+     *
+     * @return The object's prototype
+     */
+    Value prototype() const;
+
+    /**
+     * Returns the class name of the object
+     *
+     * See ECMA 8.6.2
+     *
+     * @return The object's class name
+     */
+    UString className() const;
+
+    /**
+     * Retrieves the specified property from the object. If neither the object
+     * or any other object in it's prototype chain have the property, this
+     * function will return Undefined.
+     *
+     * See ECMA 8.6.2.1
+     *
+     * @param exec The current execution state
+     * @param propertyName The name of the property to retrieve
+     *
+     * @return The specified property, or Undefined
+     */
+    Value get(ExecState *exec, const UString &propertyName) const;
+
+    /**
+     * Sets the specified property.
+     *
+     * See ECMA 8.6.2.2
+     *
+     * @param exec The current execution state
+     * @param propertyName The name of the property to set
+     * @param propertyValue The value to set
+     */
+    void put(ExecState *exec, const UString &propertyName,
+             const Value &value, int attr = None);
+
+    /**
+     * Used to check whether or not a particular property is allowed to be set
+     * on an object
+     *
+     * See ECMA 8.6.2.3
+     *
+     * @param exec The current execution state
+     * @param propertyName The name of the property
+     * @return true if the property can be set, otherwise false
+     */
+    bool canPut(ExecState *exec, const UString &propertyName) const;
+
+    /**
+     * Checks to see whether the object (or any object in it's prototype chain)
+     * has a property with the specified name.
+     *
+     * See ECMA 8.6.2.4
+     *
+     * @param exec The current execution state
+     * @param propertyName The name of the property to check for
+     * @return true if the object has the property, otherwise false
+     */
+    bool hasProperty(ExecState *exec, const UString &propertyName,
+                     bool recursive = true) const;
+
+    /**
+     * Removes the specified property from the object.
+     *
+     * See ECMA 8.6.2.5
+     *
+     * @param exec The current execution state
+     * @param propertyName The name of the property to delete
+     * @return true if the property was successfully deleted or did not
+     * exist on the object. false if deleting the specified property is not
+     * allowed.
+     */
+    bool deleteProperty(ExecState *exec, const UString &propertyName);
+
+    /**
+     * Converts the object into a primitive value. The value return may differ
+     * depending on the supplied hint
+     *
+     * See ECMA 8.6.2.6
+     *
+     * @param exec The current execution state
+     * @param hint The desired primitive type to convert to
+     * @return A primitive value converted from the objetc. Note that the
+     * type of primitive value returned may not be the same as the requested
+     * hint.
+     */
+    Value defaultValue(ExecState *exec, Type hint) const;
+
+    /**
+     * Whether or not the object implements the construct() method. If this
+     * returns false you should not call the construct() method on this
+     * object (typically, an assertion will fail to indicate this).
+     *
+     * @return true if this object implements the construct() method, otherwise
+     * false
+     */
+    bool implementsConstruct() const;
+
+    /**
+     * Creates a new object based on this object. Typically this means the
+     * following:
+     * 1. A new object is created
+     * 2. The prototype of the new object is set to the value of this object's
+     *    "prototype" property
+     * 3. The call() method of this object is called, with the new object
+     *    passed as the this value
+     * 4. The new object is returned
+     *
+     * In some cases, Host objects may differ from these semantics, although
+     * this is discouraged.
+     *
+     * If an error occurs during construction, the execution state's exception
+     * will be set. This can be tested for with @ref ExecState::hadException().
+     * Under some circumstances, the exception object may also be returned.
+     *
+     * Note: This function should not be called if implementsConstruct() returns
+     * false, in which case it will result in an assertion failure.
+     *
+     * @param exec The current execution state
+     * @param args The arguments to be passed to call() once the new object has
+     * been created
+     * @return The newly created &amp; initialized object
+     */
+    Object construct(ExecState *exec, const List &args);
+
+    /**
+     * Whether or not the object implements the call() method. If this returns
+     * false you should not call the call() method on this object (typically,
+     * an assertion will fail to indicate this).
+     *
+     * @return true if this object implements the call() method, otherwise
+     * false
+     */
+    bool implementsCall() const;
+
+
+    /**
+     * Calls this object as if it is a function.
+     *
+     * Note: This function should not be called if implementsCall() returns
+     * false, in which case it will result in an assertion failure.
+     *
+     * See ECMA 8.6.2.3
+     *
+     * @param exec The current execution state
+     * @param thisObj The obj to be used as "this" within function execution.
+     * Note that in most cases this will be different from the C++ "this"
+     * object. For example, if the ECMAScript code "window.location.toString()"
+     * is executed, call() will be invoked on the C++ object which implements
+     * the toString method, with the thisObj being window.location
+     * @param args List of arguments to be passed to the function
+     * @return The return value from the function
+     */
+    Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    /**
+     * Whether or not the object implements the hasInstance() method. If this
+     * returns false you should not call the hasInstance() method on this
+     * object (typically, an assertion will fail to indicate this).
+     *
+     * @return true if this object implements the hasInstance() method,
+     * otherwise false
+     */
+    bool implementsHasInstance() const;
+
+    /**
+     * Checks whether value delegates behaviour to this object. Used by the
+     * instanceof operator.
+     *
+     * @param exec The current execution state
+     * @param value The value to check
+     * @return true if value delegates behaviour to this object, otherwise
+     * false
+     */
+    Boolean hasInstance(ExecState *exec, const Value &value);
+
+    /**
+     * Returns the scope of this object. This is used when execution declared
+     * functions - the execution context for the function is initialized with
+     * extra object in it's scope. An example of this is functions declared
+     * inside other functions:
+     *
+     * function f() {
+     *
+     *   function b() {
+     *     return prototype;
+     *   }
+     *
+     *   var x = 4;
+     *   // do some stuff
+     * }
+     * f.prototype = new String();
+     *
+     * When the function f.b is executed, its scope will include properties of
+     * f. So in the example above the return value of f.b() would be the new
+     * String object that was assigned to f.prototype.
+     *
+     * @param exec The current execution state
+     * @return The function's scope
+     */
+    const List scope() const;
+    void setScope(const List &s);
+
+    /**
+     * Returns a List of References to all the properties of the object. Used
+     * in "for x in y" statements. The list is created new, so it can be freely
+     * modified without affecting the object's properties. It should be deleted
+     * by the caller.
+     *
+     * Subclasses can override this method in ObjectImpl to provide the
+     * appearance of
+     * having extra properties other than those set specifically with put().
+     *
+     * @param exec The current execution state
+     * @param recursive Whether or not properties in the object's prototype
+     * chain should be
+     * included in the list.
+     * @return A List of References to properties of the object.
+     **/
+    List propList(ExecState *exec, bool recursive = true);
+
+    /**
+     * Returns the internal value of the object. This is used for objects such
+     * as String and Boolean which are wrappers for native types. The interal
+     * value is the actual value represented by the wrapper objects.
+     *
+     * @see ECMA 8.6.2
+     * @return The internal value of the object
+     */
+    Value internalValue() const;
+
+    /**
+     * Sets the internal value of the object
+     *
+     * @see internalValue()
+     *
+     * @param v The new internal value
+     */
+    void setInternalValue(const Value &v);
+  };
+
+  class ObjectImp : public ValueImp {
+  public:
+    /**
+     * Creates a new ObjectImp with the specified prototype
+     *
+     * @param proto The prototype
+     */
+    ObjectImp(const Object &proto);
+
+    /**
+     * Creates a new ObjectImp with a prototype of Null()
+     * (that is, the ECMAScript "null" value, not a null Object).
+     *
+     */
+    ObjectImp();
+
+    virtual ~ObjectImp();
+
+    virtual void mark();
+
     Type type() const;
-    /**
-     * Check whether object is of a certain type
-     * @param t type to check for
-     */
-    bool isA(Type t) const { return (type() == t); }
-    /**
-     * Check whether object is of a certain type. Allows checking of
-     * host objects, too.
-     * @param type name (Number, Boolean etc.)
-     */
-    bool isA(const char *s) const;
-    /**
-     * Use this method when checking for objects. It's safer than checking
-     * for a single object type with @ref isA().
-     */
-    bool isObject() const;
-    /**
-     * Examine the inheritance structure of this object.
-     * @param t Name of the base class.
-     * @return True if object is of type t or a derived from such a type.
-     */
-    bool derivedFrom(const char *s) const;
-
-    /**
-     * @return Conversion to primitive type (Undefined, Boolean, Number
-     * or String)
-     * @param preferred Optional hint. Either StringType or NumberType.
-     */
-    KJSO toPrimitive(Type preferred = UndefinedType) const; // ECMA 9.1
-    /**
-     * @return Conversion to Boolean type.
-     */
-    Boolean toBoolean() const; // ECMA 9.2
-    /**
-     * @return Conversion to Number type.
-     */
-    Number toNumber() const; // ECMA 9.3
-    /**
-     * @return Conversion to double. 0.0 if conversion failed.
-     */
-    double round() const;
-    /**
-     * @return Conversion to Number type containing an integer value.
-     */
-    Number toInteger() const; // ECMA 9.4
-    /**
-     * @return Conversion to signed integer value.
-     */
-    int toInt32() const; // ECMA 9.5
-    /**
-     * @return Conversion to unsigned integer value.
-     */
-    unsigned int toUInt32() const; // ECMA 9.6
-    /**
-     * @return Conversion to unsigned short value.
-     */
-    unsigned short toUInt16() const; // ECMA 9.7
-    /**
-     * @return Conversion to String type.
-     */
-    String toString() const; // ECMA 9.8
-    /**
-     * @return Conversion to Object type.
-     */
-    Object toObject() const; // ECMA 9.9
-
-    // Properties
-    /**
-     * Set the internal [[Prototype]] property of this object.
-     * @param p A prototype object.
-     */
-    void setPrototype(const KJSO &p);
-    /**
-     * Set the "prototype" property of this object. Different from
-     * the internal [[Prototype]] property.
-     * @param p A prototype object.
-     */
-    void setPrototypeProperty(const KJSO &p);
-    /**
-     * @return The internal [[prototype]] property.
-     */
-    KJSO prototype() const;
-    /**
-     * The internal [[Get]] method.
-     * @return The value of property p.
-     */
-    KJSO get(const UString &p) const;
-    /**
-     * The internal [[HasProperty]] method.
-     * @param p Property name.
-     * @param recursive Indicates whether prototypes are searched as well.
-     * @return Boolean value indicating whether the object already has a
-     * member with the given name p.
-     */
-    bool hasProperty(const UString &p, bool recursive = true) const;
-    /**
-     * The internal [[Put]] method. Sets the specified property to the value v.
-     * @param p Property name.
-     * @param v Value.
-     */
-    void put(const UString &p, const KJSO& v);
-    /**
-     * The internal [[CanPut]] method.
-     * @param p Property name.
-     * @return A boolean value indicating whether a [[Put]] operation with
-     * p succeed.
-     */
-    bool canPut(const UString &p) const;
-    /**
-     * The internal [[Delete]] method. Removes the specified property from
-     * the object.
-     * @param p Property name.
-     * @return True if the property was deleted successfully or didn't exist
-     * in the first place. False if the DontDelete attribute was set.
-     */
-    bool deleteProperty(const UString &p);
-    /**
-     * Same as above put() method except the additional attribute. Right now,
-     * this only works with native types as Host Objects don't reimplement
-     * this method.
-     * @param attr One of @ref KJS::Attribute.
-     */
-    void put(const UString &p, const KJSO& v, int attr);
-    /**
-     * Convenience function for adding a Number property constructed from
-     * a double value.
-     */
-    void put(const UString &p, double d, int attr = None);
-    /**
-     * Convenience function for adding a Number property constructed from
-     * an integer value.
-     */
-    void put(const UString &p, int i, int attr = None);
-    /**
-     * Convenience function for adding a Number property constructed from
-     * an unsigned integer value.
-     */
-    void put(const UString &p, unsigned int u, int attr = None);
-
-    /**
-     * Reference method.
-     * @return Reference base if object is a reference. Throws
-     * a ReferenceError otherwise.
-     */
-    KJSO getBase() const;
-    /**
-     * Reference method.
-     * @return Property name of a reference. Null string if object is not
-     * a reference.
-     */
-    UString getPropertyName() const;
-    /**
-     * Reference method.
-     * @return Referenced value. This object if no reference.
-     */
-    KJSO getValue() const;
-    KJSO getValue();    /* TODO: remove in next version */
-    /**
-     * Reference method. Set referenced value to v.
-     */
-    ErrorType putValue(const KJSO& v);
-
-    /**
-     * @return True if object supports @ref executeCall() method. That's the
-     * case for all objects derived from FunctionType.
-     */
-    bool implementsCall() const;
-    /**
-     * Execute function implemented via the @ref Function::execute() method.
-     *
-     * Note: check availability via @ref implementsCall() beforehand.
-     * @param thisV Object serving as the 'this' value.
-     * @param args Pointer to the list of arguments or null.
-     * @return Result of the function call.
-     */
-    KJSO executeCall(const KJSO &thisV, const List *args);
-    KJSO executeCall(const KJSO &thisV, const List *args, const List *extraScope) const;
-
-    /**
-     * Set this object's constructor.
-     */
-    void setConstructor(KJSO c);
-
-    /**
-     * @return A Pointer to the internal implementation.
-     */
-    Imp *imp() const { return rep; }
-
-#ifdef KJS_DEBUG_MEM
-    /**
-     * @internal
-     */
-    static int count;
-#endif
-  protected:
-    /**
-     * Pointer to the internal implementation.
-     */
-    Imp *rep;
-
+
+    /**
+     * A pointer to a ClassInfo struct for this class. This provides a basic
+     * facility for run-time type information, and can be used to check an
+     * object's class an inheritance (see @ref inherits()). This should
+     * always return a statically declared pointer, or 0 to indicate that
+     * there is no class information.
+     *
+     * This is primarily useful if you have application-defined classes that you
+     * wish to check against for casting purposes.
+     *
+     * For example, to specify the class info for classes FooImp and BarImp,
+     * where FooImp inherits from BarImp, you would add the following in your
+     * class declarations:
+     *
+     *   class BarImp : public ObjectImp {
+     *     virtual const ClassInfo *classInfo() const { return &info; }
+     *     static const ClassInfo info;
+     *     // ...
+     *   };
+     *
+     *   class FooImp : public ObjectImp {
+     *     virtual const ClassInfo *classInfo() const { return &info; }
+     *     static const ClassInfo info;
+     *     // ...
+     *   };
+     *
+     * And in your source file:
+     *
+     *   const ClassInfo BarImp::info = {0, 0, 0}; // no parent class
+     *   const ClassInfo FooImp::info = {&BarImp::info, 0, 0};
+     *
+     * @see inherits()
+     */
+    virtual const ClassInfo *classInfo() const;
+
+    /**
+     * Checks whether this object inherits from the class with the specified
+     * classInfo() pointer. This requires that both this class and the other
+     * class return a non-NULL pointer for their classInfo() methods (otherwise
+     * it will return false).
+     *
+     * For example, for two ObjectImp pointers obj1 and obj2, you can check
+     * if obj1's class inherits from obj2's class using the following:
+     *
+     *   if (obj1->inherits(obj2->classInfo())) {
+     *     // ...
+     *   }
+     *
+     * If you have a handle to a statically declared ClassInfo, such as in the
+     * @ref classInfo() example, you can check for inheritance without needing
+     * an instance of the other class:
+     *
+     *   if (obj1->inherits(FooImp::info)) {
+     *     // ...
+     *   }
+     *
+     * @param cinfo The ClassInfo pointer for the class you want to check
+     * inheritance against.
+     * @return true if this object's class inherits from class with the
+     * ClassInfo pointer specified in cinfo
+     */
+    bool inherits(const ClassInfo *cinfo) const;
+
+    // internal properties (ECMA 262-3 8.6.2)
+
+    /**
+     * Implementation of the [[Prototype]] internal property (implemented by
+     * all Objects)
+     *
+     * @see Object::prototype()
+     */
+    Value prototype() const;
+    void setPrototype(const Value &proto);
+
+    /**
+     * Implementation of the [[Class]] internal property (implemented by all
+     * Objects)
+     *
+     * The default implementation uses classInfo().
+     * You should either implement @ref classInfo(), or
+     * if you simply need a classname, you can reimplement @ref className()
+     * instead.
+     *
+     * @see Object::className()
+     */
+    virtual UString className() const;
+
+    /**
+     * Implementation of the [[Get]] internal property (implemented by all
+     * Objects)
+     *
+     * @see Object::get()
+     */
+    // [[Get]] - must be implemented by all Objects
+    virtual Value get(ExecState *exec, const UString &propertyName) const;
+
+    /**
+     * Implementation of the [[Put]] internal property (implemented by all
+     * Objects)
+     *
+     * @see Object::put()
+     */
+    virtual void put(ExecState *exec, const UString &propertyName,
+                     const Value &value, int attr = None);
+
+    /**
+     * Implementation of the [[CanPut]] internal property (implemented by all
+     * Objects)
+     *
+     * @see Object::canPut()
+     */
+    virtual bool canPut(ExecState *exec, const UString &propertyName) const;
+
+    /**
+     * Implementation of the [[HasProperty]] internal property (implemented by
+     * all Objects)
+     *
+     * @see Object::hasProperty()
+     */
+    virtual bool hasProperty(ExecState *exec, const UString &propertyName,
+                             bool recursive = true) const;
+
+    /**
+     * Implementation of the [[Delete]] internal property (implemented by all
+     * Objects)
+     *
+     * @see Object::deleteProperty()
+     */
+    virtual bool deleteProperty(ExecState *exec,
+                                const UString &propertyName);
+
+    /**
+     * Remove all properties from this object.
+     * This doesn't take DontDelete into account, and isn't in the ECMA spec.
+     * It's simply a quick way to remove everything before destroying.
+     */
+    void deleteAllProperties( ExecState * );
+
+    /**
+     * Implementation of the [[DefaultValue]] internal property (implemented by
+     * all Objects)
+     *
+     * @see Object::defaultValue()
+     */
+    virtual Value defaultValue(ExecState *exec, Type hint) const;
+
+    virtual bool implementsConstruct() const;
+    /**
+     * Implementation of the [[Construct]] internal property
+     *
+     * @see Object::construct()
+     */
+    virtual Object construct(ExecState *exec, const List &args);
+
+    virtual bool implementsCall() const;
+    /**
+     * Implementation of the [[Call]] internal property
+     *
+     * @see Object::call()
+     */
+    virtual Value call(ExecState *exec, Object &thisObj,
+                       const List &args);
+
+    virtual bool implementsHasInstance() const;
+    /**
+     * Implementation of the [[HasInstance]] internal property
+     *
+     * @see Object::hasInstance()
+     */
+    virtual Boolean hasInstance(ExecState *exec, const Value &value);
+
+    /**
+     * Implementation of the [[Scope]] internal property
+     *
+     * @see Object::scope()
+     */
+    const List scope() const;
+    void setScope(const List &s);
+
+    List propList(ExecState *exec, bool recursive = true);
+
+    Value internalValue() const;
+    void setInternalValue(const Value &v);
+
+    Value toPrimitive(ExecState *exec,
+                      Type preferredType = UnspecifiedType) const;
+    bool toBoolean(ExecState *exec) const;
+    double toNumber(ExecState *exec) const;
+    int toInteger(ExecState *exec) const;
+    int toInt32(ExecState *exec) const;
+    unsigned int toUInt32(ExecState *exec) const;
+    unsigned short toUInt16(ExecState *exec) const;
+    UString toString(ExecState *exec) const;
+    Object toObject(ExecState *exec) const;
+
+    ValueImp* getDirect(const UString& propertyName) const;
   private:
-    void putArrayElement(const UString &p, const KJSO &v);
-  }; // end of KJSO
+    const HashEntry* findPropertyHashEntry( const UString& propertyName ) const;
+    ObjectImpPrivate *_od;
+    PropertyMap *_prop;
+    ValueImp *_proto;
+    ValueImp *_internalValue;
+    ListImp *_scope;
+  };
 
   /**
-   * @short Base for all implementation classes.
+   * Types of Native Errors available. For custom errors, GeneralError
+   * should be used.
    */
-  class Imp {
-    friend class KJSO;
-    friend class Collector;
-    friend class ForInNode;
-    friend class Debugger;
-  public:
-    Imp();
-  public:
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const; // ECMA 9.1
-    virtual Boolean toBoolean() const; // ECMA 9.2
-    virtual Number toNumber() const; // ECMA 9.3
-    virtual String toString() const; // ECMA 9.8
-    virtual Object toObject() const; // ECMA 9.9
-
-    // properties
-    virtual KJSO get(const UString &p) const;
-    virtual bool hasProperty(const UString &p, bool recursive = true) const;
-    virtual void put(const UString &p, const KJSO& v);
-    void put(const UString &p, const KJSO& v, int attr);
-    virtual bool canPut(const UString &p) const;
-    virtual bool deleteProperty(const UString &p);
-    virtual KJSO defaultValue(Type hint) const;
-
-    bool implementsCall() const;
-
-    /**
-     * @internal Reserved for mark & sweep garbage collection
-     */
-    virtual void mark(Imp *imp = 0L);
-    bool marked() const;
-
-    Type type() const { return typeInfo()->type; }
-    /**
-     * @return The TypeInfo struct describing this object.
-     */
-    virtual const TypeInfo* typeInfo() const { return &info; }
-
-    void setPrototype(const KJSO& p);
-    Imp* prototype() const { return proto; }
-    void setPrototypeProperty(const KJSO &p);
-    void setConstructor(const KJSO& c);
-
-    void* operator new(size_t);
-    void operator delete(void*);
-    /**
-     * @deprecated
-     */
-    void operator delete(void*, size_t);
-
-#ifdef KJS_DEBUG_MEM
-    /**
-     * @internal
-     */
-    static int count;
-#endif
-  protected:
-    virtual ~Imp();
-  private:
-    Imp(const Imp&);
-    Imp& operator=(const Imp&);
-    void putArrayElement(const UString &p, const KJSO& v);
-
-    /**
-     * Get the property names for this object. To be used by for .. in loops
-     * @return The (pointer to the) first element of a PropList, to be deleted
-     * by the caller, or 0 if there are no enumerable properties
-     */
-    PropList *propList(PropList *first = 0L, PropList *last = 0L,
-                       bool recursive = true) const;
-
-  public:
-    // reference counting mechanism
-    inline Imp* ref() { refcount++; return this; }
-    inline bool deref() { return (!--refcount); }
-    unsigned int refcount;
-
-  private:
-    Property *prop;
-    Imp *proto;
-    static const TypeInfo info;
-
-    // reserved for memory managment - currently used as flags for garbage collection
-    // (prev != 0) = marked, (next != 0) = created, (next != this) = created and gc allowed
-    Imp *prev, *next;
-    // for future extensions
-    class ImpInternal;
-    ImpInternal *internal;
-
-    void setMarked(bool m);
-    void setGcAllowed(bool a);
-    bool gcAllowed() const;
-    void setCreated(bool c);
-    bool created() const;
-  };
-
-  /**
-   * @short General implementation class for Objects
-   */
-  class ObjectImp : public Imp {
-    friend class Object;
-  public:
-    ObjectImp(Class c);
-    ObjectImp(Class c, const KJSO &v);
-    ObjectImp(Class c, const KJSO &v, const KJSO &p);
-    virtual ~ObjectImp();
-    virtual KJSO toPrimitive(Type preferred = UndefinedType) const;
-    virtual Boolean toBoolean() const;
-    virtual Number toNumber() const;
-    virtual String toString() const;
-    virtual Object toObject() const;
-
-    virtual const TypeInfo* typeInfo() const { return &info; }
-    static const TypeInfo info;
-    /**
-     * @internal Reimplemenation of @ref Imp::mark().
-     */
-    virtual void mark(Imp *imp = 0L);
-  private:
-    Class cl;
-    Imp *val;
-  };
-
-  /**
-   * @short Object class encapsulating an internal value.
-   */
-  class Object : public KJSO {
-  public:
-    Object(Imp *d);
-    Object(Class c = UndefClass);
-    Object(Class c, const KJSO& v);
-    Object(Class c, const KJSO& v, const Object& p);
-    virtual ~Object();
-    void setClass(Class c);
-    Class getClass() const;
-    void setInternalValue(const KJSO& v);
-    KJSO internalValue();
-    static Object create(Class c);
-    static Object create(Class c, const KJSO& val);
-    static Object create(Class c, const KJSO& val, const Object &p);
-    static Object dynamicCast(const KJSO &obj);
-  };
-
-  /**
-   * @short Implementation base class for Host Objects.
-   */
-  class HostImp : public Imp {
-  public:
-    HostImp();
-    virtual ~HostImp();
-    virtual const TypeInfo* typeInfo() const { return &info; }
-
-    virtual Boolean toBoolean() const;
-    virtual String toString() const;
-
-    static const TypeInfo info;
-  };
-
-  class KJScriptImp;
-  /**
-   * The Global object represents the global namespace. It holds the native
-   * objects like String and functions like eval().
-   *
-   * It also serves as a container for variables created by the user, i.e.
-   * the statement
-   * <pre>
-   *   var i = 2;
-   * </pre>
-   * will basically perform a Global::current().put("i", Number(2)); operation.
-   *
-   * @short Unique global object containing initial native properties.
-   */
-  class Global : public Object {
-    friend class KJScriptImp;
-  public:
-    /**
-     * Constructs a Global object. This is done by the interpreter once and
-     * there should be no need to create an instance on your own. Usually,
-     * you'll just want to access the current instance.
-     * For example like this:
-     * <pre>
-     * Global global(Global::current());
-     * KJSO proto = global.objectPrototype();
-     * </pre>
-     */
-    Global();
-    /**
-     * Destruct the Global object.
-     */
-    virtual ~Global();
-    /**
-     * @return A reference to the Global object belonging to the current
-     * interpreter instance.
-     */
-    static Global current();
-    /**
-     * @return A handle to Object.prototype.
-     */
-    KJSO objectPrototype() const;
-    /**
-     * @return A handle to Function.prototype.
-     */
-    KJSO functionPrototype() const;
-    /**
-     * Set a filter object that will intercept all put() and get() calls
-     * to the global object. If this object returns Undefined on get() the
-     * request will be passed on the global object.
-     * @deprecated
-     */
-    void setFilter(const KJSO &f);
-    /**
-     * Return a handle to the filter object (see @ref setFilter()).
-     * Null if no filter has been installed.
-     * @deprecated
-     */
-    KJSO filter() const;
-    /**
-     * Returns the extra user data set for this global object. Null by default.
-     * Typical usage if you need to query any info related to the currently
-     * running interpreter:
-     *
-     *    MyMainWindow *m = (MyMainWindow*)Global::current().extra();
-     */
-    void *extra() const;
-    /**
-     * Set the extra user data for this global object. It's not used by the
-     * interpreter itself and can therefore be used to bind arbitrary data
-     * to each interpreter instance.
-     */
-    void setExtra(void *e);
-  private:
-    Global(void *);
-    void init();
-    void clear();
-  };
+  enum ErrorType { GeneralError   = 0,
+                   EvalError      = 1,
+                   RangeError     = 2,
+                   ReferenceError = 3,
+                   SyntaxError    = 4,
+                   TypeError      = 5,
+                   URIError       = 6};
 
   /**
@@ -621 +592 @@
   public:
     /**
-     * Factory method for error objects. The error will be registered globally
-     * and the execution will continue as if a "throw" statement was
-     * encountered.
-     * @param e Type of error.
-     * @param m Optional error message.
-     * @param l Optional line number.
-     */
-    static KJSO create(ErrorType e, const char *m = 0, int l = -1);
-    /**
-     * Same as above except the different return type (which is not casted
-     * here).
-     */
-    static Object createObject(ErrorType e, const char *m = 0, int l = -1);
+     * Factory method for error objects.
+     *
+     * @param exec The current execution state
+     * @param errtype Type of error.
+     * @param message Optional error message.
+     * @param lineno Optional line number.
+     * @param lineno Optional source id.
+     */
+    static Object create(ExecState *exec, ErrorType errtype = GeneralError,
+                         const char *message = 0, int lineno = -1,
+                         int sourceId = -1);
+
+    /**
+     * Array of error names corresponding to @ref ErrorType
+     */
+    static const char * const * const errorNames;
   };
 
 }; // namespace
 
-#endif
+#endif // _KJS_OBJECT_H_

trunk/JavaScriptCore/kjs/object_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 "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "operations.h"
 #include "object_object.h"
-#include "types.h"
+#include "function_object.h"
 #include <stdio.h>
+#include <assert.h>
 
 using namespace KJS;
 
-ObjectObject::ObjectObject(const Object &funcProto, const Object &objProto)
-    : ConstructorImp(funcProto, 1)
+// ------------------------------ ObjectPrototypeImp --------------------------------
+
+ObjectPrototypeImp::ObjectPrototypeImp(ExecState *exec,
+                                       FunctionPrototypeImp *funcProto)
+  : ObjectImp() // [[Prototype]] is Null()
 {
-  // ECMA 15.2.3.1
-  setPrototypeProperty(objProto);
+  Value protect(this);
+  put(exec,"toString", Object(new ObjectProtoFuncImp(exec,funcProto,ObjectProtoFuncImp::ToString, 0)), DontEnum);
+  put(exec,"valueOf",  Object(new ObjectProtoFuncImp(exec,funcProto,ObjectProtoFuncImp::ValueOf,  0)), DontEnum);
 }
 
-Completion ObjectObject::execute(const List &args)
+
+// ------------------------------ ObjectProtoFuncImp --------------------------------
+
+ObjectProtoFuncImp::ObjectProtoFuncImp(ExecState *exec,
+                                       FunctionPrototypeImp *funcProto,
+                                       int i, int len)
+  : InternalFunctionImp(funcProto), id(i)
 {
-  KJSO result;
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
 
-  List argList;
-  if (args.isEmpty()) {
-    result = construct(argList);
-  } else {
-    KJSO arg = args[0];
-    if (arg.isA(NullType) || arg.isA(UndefinedType)) {
-      argList.append(arg);
-      result = construct(argList);
-    } else
-      result = arg.toObject();
-  }
-  return Completion(ReturnValue, result);
+
+bool ObjectProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.2.4.2 + 15.2.4.3
+
+Value ObjectProtoFuncImp::call(ExecState */*exec*/, Object &thisObj, const List &/*args*/)
+{
+  if (id == ValueOf)
+    return thisObj;
+  else /* ToString */
+    return String("[object "+thisObj.className()+"]");
+}
+
+// ------------------------------ ObjectObjectImp --------------------------------
+
+ObjectObjectImp::ObjectObjectImp(ExecState *exec,
+                                 ObjectPrototypeImp *objProto,
+                                 FunctionPrototypeImp *funcProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
+  // ECMA 15.2.3.1
+  put(exec,"prototype", Object(objProto), DontEnum|DontDelete|ReadOnly);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+}
+
+
+bool ObjectObjectImp::implementsConstruct() const
+{
+  return true;
 }
 
 // ECMA 15.2.2
-Object ObjectObject::construct(const List &args)
+Object ObjectObjectImp::construct(ExecState *exec, const List &args)
 {
   // if no arguments have been passed ...
-  if (args.isEmpty())
-    return Object::create(ObjectClass);
+  if (args.isEmpty()) {
+    Object proto = exec->interpreter()->builtinObjectPrototype();
+    Object result(new ObjectImp(proto));
+    return result;
+  }
 
-  KJSO arg = *args.begin();
+  Value arg = *(args.begin());
   Object obj = Object::dynamicCast(arg);
   if (!obj.isNull()) {
-    /* TODO: handle host objects */
     return obj;
   }
@@ -69 +113 @@
   case BooleanType:
   case NumberType:
-    return arg.toObject();
+    return arg.toObject(exec);
   default:
     assert(!"unhandled switch case in ObjectConstructor");
   case NullType:
   case UndefinedType:
-    return Object::create(ObjectClass);
+    Object proto = exec->interpreter()->builtinObjectPrototype();
+    return Object(new ObjectImp(proto));
   }
 }
 
-ObjectPrototype::ObjectPrototype()
-  : ObjectImp(ObjectClass)
+bool ObjectObjectImp::implementsCall() const
 {
-  // the spec says that [[Property]] should be `null'.
-  // Not sure if Null or C's NULL is needed.
+  return true;
 }
 
-bool ObjectPrototype::hasProperty(const UString &p, bool recursive) const
+Value ObjectObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
 {
-    if ( p == "toString" || p == "valueOf" )
-        return true;
-    return /*recursive &&*/ ObjectImp::hasProperty(p, recursive);
+  Value result;
+
+  List argList;
+  // Construct a new Object
+  if (args.isEmpty()) {
+    result = construct(exec,argList);
+  } else {
+    Value arg = args[0];
+    if (arg.type() == NullType || arg.type() == UndefinedType) {
+      argList.append(arg);
+      result = construct(exec,argList);
+    } else
+      result = arg.toObject(exec);
+  }
+  return result;
 }
 
-KJSO ObjectPrototype::get(const UString &p) const
-{
-  if (p == "toString")
-    return Function(new ObjectProtoFunc(ToString));
-  else if (p == "valueOf")
-    return Function(new ObjectProtoFunc(ValueOf));
-  else
-    return Imp::get(p);
-}
-
-ObjectProtoFunc::ObjectProtoFunc(int i)
-  : id(i)
-{
-}
-
-// ECMA 15.2.4.2 + 15.2.4.3
-Completion ObjectProtoFunc::execute(const List &)
-{
-  Object thisObj = Object::dynamicCast(thisValue());
-
-  /* TODO: what to do with non-objects. Is this possible at all ? */
-  // Yes, this happens with Host Object at least (David)
-  if (thisObj.isNull()) {
-    UString str = "[object ";
-    str += thisValue().isNull() ? "null" : thisValue().imp()->typeInfo()->name;
-    str += "]";
-    return Completion(ReturnValue, String(str));
-  }
-
-  // valueOf()
-  if (id == ObjectPrototype::ValueOf)
-    /* TODO: host objects*/
-    return Completion(ReturnValue, thisObj);
-
-  // toString()
-  UString str;
-  switch(thisObj.getClass()) {
-  case StringClass:
-    str = "[object String]";
-    break;
-  case BooleanClass:
-    str = "[object Boolean]";
-    break;
-  case NumberClass:
-    str = "[object Number]";
-    break;
-  case ObjectClass:
-  {
-    str = "[object ";
-    str += thisValue().isNull() ? "Object" : thisValue().imp()->typeInfo()->name;
-    str += "]";
-    break;
-  }
-  default:
-    str = "[undefined object]";
-  }
-
-  return Completion(ReturnValue, String(str));
-}

trunk/JavaScriptCore/kjs/object_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _OBJECT_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
 
 namespace KJS {
 
-  class ObjectObject : public ConstructorImp {
+  class FunctionPrototypeImp;
+
+  /**
+   * @internal
+   *
+   * The initial value of Object.prototype (and thus all objects created
+   * with the Object constructor
+   */
+  class ObjectPrototypeImp : public ObjectImp {
   public:
-    ObjectObject(const Object &funcProto, const Object &objProto);
-    Completion execute(const List &);
-    Object construct(const List &);
+    ObjectPrototypeImp(ExecState *exec, FunctionPrototypeImp *funcProto);
   };
 
-  class ObjectPrototype : public ObjectImp {
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * Object.prototype object
+   */
+  class ObjectProtoFuncImp : public InternalFunctionImp {
   public:
-    ObjectPrototype();
-    bool hasProperty(const UString &p, bool recursive) const;
-    KJSO get(const UString &p) const;
+    ObjectProtoFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto,
+                       int i, int len);
+
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
     enum { ToString, ValueOf };
+  private:
+    int id;
   };
 
-  class ObjectProtoFunc : public InternalFunctionImp {
+  /**
+   * @internal
+   *
+   * The initial value of the the global variable's "Object" property
+   */
+  class ObjectObjectImp : public InternalFunctionImp {
   public:
-    ObjectProtoFunc(int i);
-    Completion execute(const List &);
-  private:
-    int id;
+
+    ObjectObjectImp(ExecState *exec,
+                    ObjectPrototypeImp *objProto,
+                    FunctionPrototypeImp *funcProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
   };
 

trunk/JavaScriptCore/kjs/operations.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
  */
 
@@ -42 +44 @@
 #endif
 
+#include "operations.h"
 #include "object.h"
-#include "types.h"
-#include "operations.h"
 
 using namespace KJS;
@@ -72 +73 @@
 }
 
+bool KJS::isPosInf(double d)
+{
+#if defined(HAVE_FUNC_ISINF)
+  return (isinf(d) == 1);
+#elif HAVE_FUNC_FINITE
+  return finite(d) == 0 && d == d; // ### can we distinguish between + and - ?
+#elif HAVE_FUNC__FINITE
+  return _finite(d) == 0 && d == d; // ###
+#else
+  return false;
+#endif
+}
+
+bool KJS::isNegInf(double d)
+{
+#if defined(HAVE_FUNC_ISINF)
+  return (isinf(d) == -1);
+#elif HAVE_FUNC_FINITE
+  return finite(d) == 0 && d == d; // ###
+#elif HAVE_FUNC__FINITE
+  return _finite(d) == 0 && d == d; // ###
+#else
+  return false;
+#endif
+}
+
 // ECMA 11.9.3
-bool KJS::equal(const KJSO& v1, const KJSO& v2)
+bool KJS::equal(ExecState *exec, const Value& v1, const Value& v2)
 {
   Type t1 = v1.type();
@@ -82 +109 @@
       return true;
     if (t1 == NumberType)
-      return (v1.toNumber().value() == v2.toNumber().value()); /* TODO: NaN, -0 ? */
+    {
+      double d1 = v1.toNumber(exec);
+      double d2 = v2.toNumber(exec);
+      if ( isNaN( d1 ) || isNaN( d2 ) )
+        return false;
+      return ( d1 == d2 ); /* TODO: +0, -0 ? */
+    }
     if (t1 == StringType)
-      return (v1.toString().value() == v2.toString().value());
+      return (v1.toString(exec) == v2.toString(exec));
     if (t1 == BooleanType)
-      return (v1.toBoolean().value() == v2.toBoolean().value());
-    if (t1 == HostType) {
-        KJSO h1 = v1.get("[[==]]");
-        KJSO h2 = v2.get("[[==]]");
-        if (!h1.isA(UndefinedType) && !h2.isA(UndefinedType))
-            return equal(h1, h2);
-    }
+      return (v1.toBoolean(exec) == v2.toBoolean(exec));
+
+    // types are Object
     return (v1.imp() == v2.imp());
   }
@@ -100 +129 @@
     return true;
   if (t1 == NumberType && t2 == StringType) {
-    Number n2 = v2.toNumber();
-    return equal(v1, n2);
+    Number n2 = v2.toNumber(exec);
+    return equal(exec,v1, n2);
   }
   if ((t1 == StringType && t2 == NumberType) || t1 == BooleanType) {
-    Number n1 = v1.toNumber();
-    return equal(n1, v2);
+    Number n1 = v1.toNumber(exec);
+    return equal(exec,n1, v2);
   }
   if (t2 == BooleanType) {
-    Number n2 = v2.toNumber();
-    return equal(v1, n2);
+    Number n2 = v2.toNumber(exec);
+    return equal(exec,v1, n2);
   }
   if ((t1 == StringType || t1 == NumberType) && t2 >= ObjectType) {
-    KJSO p2 = v2.toPrimitive();
-    return equal(v1, p2);
+    Value p2 = v2.toPrimitive(exec);
+    return equal(exec,v1, p2);
   }
   if (t1 >= ObjectType && (t2 == StringType || t2 == NumberType)) {
-    KJSO p1 = v1.toPrimitive();
-    return equal(p1, v2);
-  }
-
-  return false;
-}
-
-bool KJS::strictEqual(const KJSO &v1, const KJSO &v2)
+    Value p1 = v1.toPrimitive(exec);
+    return equal(exec,p1, v2);
+  }
+
+  return false;
+}
+
+bool KJS::strictEqual(ExecState *exec, const Value &v1, const Value &v2)
 {
   Type t1 = v1.type();
@@ -133 +162 @@
     return true;
   if (t1 == NumberType) {
-    double n1 = v1.toNumber().value();
-    double n2 = v2.toNumber().value();
+    double n1 = v1.toNumber(exec);
+    double n2 = v2.toNumber(exec);
     if (isNaN(n1) || isNaN(n2))
       return false;
@@ -142 +171 @@
     return false;
   } else if (t1 == StringType) {
-    return v1.toString().value() == v2.toString().value();
+    return v1.toString(exec) == v2.toString(exec);
   } else if (t2 == BooleanType) {
-    return v1.toBoolean().value() == v2.toBoolean().value();
+    return v1.toBoolean(exec) == v2.toBoolean(exec);
   }
   if (v1.imp() == v2.imp())
@@ -153 +182 @@
 }
 
-int KJS::relation(const KJSO& v1, const KJSO& v2)
-{
-  KJSO p1 = v1.toPrimitive(NumberType);
-  KJSO p2 = v2.toPrimitive(NumberType);
-
-  if (p1.isA(StringType) && p2.isA(StringType))
-    return p1.toString().value() < p2.toString().value() ? 1 : 0;
-
-  Number n1 = p1.toNumber();
-  Number n2 = p2.toNumber();
-  /* TODO: check for NaN */
-  if (n1.value() == n2.value())
+int KJS::relation(ExecState *exec, const Value& v1, const Value& v2)
+{
+  Value p1 = v1.toPrimitive(exec,NumberType);
+  Value p2 = v2.toPrimitive(exec,NumberType);
+
+  if (p1.type() == StringType && p2.type() == StringType)
+    return p1.toString(exec) < p2.toString(exec) ? 1 : 0;
+
+  double n1 = p1.toNumber(exec);
+  double n2 = p2.toNumber(exec);
+  if ( isNaN( n1 ) || isNaN( n2 ) )
+    return -1; // means undefined
+  if (n1 == n2)
     return 0;
-  /* TODO: +0, -0 and Infinity */
-  return (n1.value() < n2.value());
-}
-
-double KJS::max(double d1, double d2)
-{
-  /* TODO: check for NaN */
+  /* TODO: +0, -0 */
+  if ( isPosInf( n1 ) )
+    return 0;
+  if ( isPosInf( n2 ) )
+    return 1;
+  if ( isNegInf( n2 ) )
+    return 0;
+  if ( isNegInf( n1 ) )
+    return 1;
+  return (n1 < n2) ? 1 : 0;
+}
+
+int KJS::maxInt(int d1, int d2)
+{
   return (d1 > d2) ? d1 : d2;
 }
 
-double KJS::min(double d1, double d2)
-{
-  /* TODO: check for NaN */
+int KJS::minInt(int d1, int d2)
+{
   return (d1 < d2) ? d1 : d2;
 }
 
 // ECMA 11.6
-KJSO KJS::add(const KJSO &v1, const KJSO &v2, char oper)
-{
-  KJSO p1 = v1.toPrimitive();
-  KJSO p2 = v2.toPrimitive();
-
-  if ((p1.isA(StringType) || p2.isA(StringType)) && oper == '+') {
-    String s1 = p1.toString();
-    String s2 = p2.toString();
-
-    UString s = s1.value() + s2.value();
-
-    return String(s);
-  }
-
-  Number n1 = p1.toNumber();
-  Number n2 = p2.toNumber();
+Value KJS::add(ExecState *exec, const Value &v1, const Value &v2, char oper)
+{
+  Value p1 = v1.toPrimitive(exec);
+  Value p2 = v2.toPrimitive(exec);
+
+  if ((p1.type() == StringType || p2.type() == StringType) && oper == '+') {
+    UString s1 = p1.toString(exec);
+    UString s2 = p2.toString(exec);
+
+    return String(s1 + s2);
+  }
+
+  double n1 = p1.toNumber(exec);
+  double n2 = p2.toNumber(exec);
 
   if (oper == '+')
-    return Number(n1.value() + n2.value());
+    return Number(n1 + n2);
   else
-    return Number(n1.value() - n2.value());
+    return Number(n1 - n2);
 }
 
 // ECMA 11.5
-KJSO KJS::mult(const KJSO &v1, const KJSO &v2, char oper)
-{
-  Number n1 = v1.toNumber();
-  Number n2 = v2.toNumber();
+Value KJS::mult(ExecState *exec, const Value &v1, const Value &v2, char oper)
+{
+  Number n1 = v1.toNumber(exec);
+  Number n2 = v2.toNumber(exec);
 
   double result;

trunk/JavaScriptCore/kjs/operations.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
@@ -22 +25 @@
 #define _KJS_OPERATIONS_H_
 
-#include "object.h"
+#include "value.h"
 
 namespace KJS {
+
+  class ExecState;
 
   /**
@@ -34 +39 @@
    */
   bool isInf(double d);
-  bool equal(const KJSO& v1, const KJSO& v2);
-  bool strictEqual(const KJSO &v1, const KJSO &v2);
+  bool isPosInf(double d);
+  bool isNegInf(double d);
+  bool equal(ExecState *exec, const Value& v1, const Value& v2);
+  bool strictEqual(ExecState *exec, const Value &v1, const Value &v2);
   /**
    * This operator performs an abstract relational comparision of the two
@@ -44 +51 @@
    * equal". -1 if the result is undefined.
    */
-  int relation(const KJSO& v1, const KJSO& v2);
-  double max(double d1, double d2);
-  double min(double d1, double d2);
+  int relation(ExecState *exec, const Value& v1, const Value& v2);
+  int maxInt(int d1, int d2);
+  int minInt(int d1, int d2);
   /**
    * Additive operator. Either performs an addition or substraction of v1
@@ -53 +60 @@
    * @return The result of the operation.
    */
-  KJSO add(const KJSO &v1, const KJSO &v2, char oper);
+  Value add(ExecState *exec, const Value &v1, const Value &v2, char oper);
   /**
    * Multiplicative operator. Either multiplies/divides v1 and v2 or
@@ -61 +68 @@
    * @return The result of the operation.
    */
-  KJSO mult(const KJSO &v1, const KJSO &v2, char oper);
+  Value mult(ExecState *exec, const Value &v1, const Value &v2, char oper);
 
 };

trunk/JavaScriptCore/kjs/regexp.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 <stdlib.h>
+#include <string.h>
 
-#include "object.h"
 #include "regexp.h"
 
@@ -26 +30 @@
 
 RegExp::RegExp(const UString &p, int f)
- : pattern(p), flags(f)
+  : pattern(p), flags(f)
 {
-#ifdef REG_EXTENDED    
-  regcomp(&preg, p.ascii(), REG_EXTENDED);
-#else
-  regcomp(&preg, p.ascii(), 0);  
-#endif  
-  /* TODO use flags, check for errors */
+
+#ifdef HAVE_PCREPOSIX
+  int pcreflags = 0;
+  const char *perrormsg;
+  int errorOffset;
+
+  if (flags & IgnoreCase)
+    pcreflags |= PCRE_CASELESS;
+
+  if (flags & Multiline)
+    pcreflags |= PCRE_MULTILINE;
+
+  pcregex = pcre_compile(p.ascii(), pcreflags,
+                         &perrormsg, &errorOffset, NULL);
+
+#ifdef PCRE_INFO_CAPTURECOUNT
+  // Get number of subpatterns that will be returned
+  int rc = pcre_fullinfo( pcregex, NULL, PCRE_INFO_CAPTURECOUNT, &nrSubPatterns);
+  if (rc != 0)
+#endif
+    nrSubPatterns = 0; // fallback. We always need the first pair of offsets.
+
+#else /* HAVE_PCREPOSIX */
+
+  nrSubPatterns = 0; // not implemented with POSIX regex.
+  int regflags = 0;
+#ifdef REG_EXTENDED
+  regflags |= REG_EXTENDED;
+#endif
+#ifdef REG_ICASE
+  if ( f & IgnoreCase )
+    regflags |= REG_ICASE;
+#endif
+
+  //NOTE: Multiline is not feasible with POSIX regex.
+  //if ( f & Multiline )
+  //    ;
+  // Note: the Global flag is already handled by RegExpProtoFunc::execute
+
+  regcomp(&preg, p.ascii(), regflags);
+  /* TODO check for errors */
+#endif
+
 }
 
 RegExp::~RegExp()
 {
+#ifdef HAVE_PCREPOSIX
+  pcre_free(pcregex);
+
+#else
   /* TODO: is this really okay after an error ? */
   regfree(&preg);
+#endif
 }
 
-UString RegExp::match(const UString &s, int i, int *pos)
+UString RegExp::match(const UString &s, int i, int *pos, int **ovector)
 {
+
+#ifdef HAVE_PCREPOSIX
+  CString buffer(s.cstring());
+  int ovecsize = (nrSubPatterns+1)*3; // see pcre docu
+  if (ovector) *ovector = new int[ovecsize];
+
+  if (i < 0)
+    i = 0;
+
+  if (i > s.size() || s.isNull() ||
+      pcre_exec(pcregex, NULL, buffer.c_str(), buffer.size(), i,
+                0, ovector ? *ovector : 0L, ovecsize) == PCRE_ERROR_NOMATCH) {
+
+    if (pos)
+       *pos = -1;
+    return UString::null;
+  }
+
+  if (!ovector)
+    return UString::null; // don't rely on the return value if you pass ovector==0
+  if (pos)
+     *pos = (*ovector)[0];
+  return s.substr((*ovector)[0], (*ovector)[1] - (*ovector)[0]);
+
+#else
   regmatch_t rmatch[10];
 
@@ -49 +120 @@
     i = 0;
 
+  char *str = strdup(s.ascii());
   if (i > s.size() || s.isNull() ||
-      regexec(&preg, s.ascii() + i, 10, rmatch, 0)) {
+      regexec(&preg, str + i, 10, rmatch, 0)) {
     if (pos)
-      *pos = -1;
+       *pos = -1;
     return UString::null;
   }
+  free(str);
 
   if (pos)
-    *pos = rmatch[0].rm_so + i;
+     *pos = rmatch[0].rm_so + i;
+  // TODO copy from rmatch to ovector
   return s.substr(rmatch[0].rm_so + i, rmatch[0].rm_eo - rmatch[0].rm_so);
+#endif
 }
 
+#if 0 // unused
 bool RegExp::test(const UString &s, int)
 {
-  int r = regexec(&preg, s.ascii(), 0, 0, 0);
+#ifdef HAVE_PCREPOSIX
+  int ovector[300];
+  CString buffer(s.cstring());
+
+  if (s.isNull() ||
+      pcre_exec(pcregex, NULL, buffer.c_str(), buffer.size(), 0,
+                0, ovector, 300) == PCRE_ERROR_NOMATCH)
+    return false;
+  else
+    return true;
+
+#else
+
+  char *str = strdup(s.ascii());
+  int r = regexec(&preg, str, 0, 0, 0);
+  free(str);
 
   return r == 0;
+#endif
 }
+#endif

trunk/JavaScriptCore/kjs/regexp.h

@@ +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$
  */
 
@@ -27 +30 @@
 #ifdef HAVE_PCREPOSIX
 #include <pcreposix.h>
+#include <pcre.h>
 #else  // POSIX regex - not so good...
 extern "C" { // bug with some libc5 distributions
@@ -39 +43 @@
   class RegExp {
   public:
-    enum { None, Global, IgnoreCase, Multiline };
+    enum { None = 0, Global = 1, IgnoreCase = 2, Multiline = 4 };
     RegExp(const UString &p, int f = None);
     ~RegExp();
-    UString match(const UString &s, int i = -1, int *pos = 0L);
-    bool test(const UString &s, int i = -1);
+    UString match(const UString &s, int i = -1, int *pos = 0L, int **ovector = 0L);
+    // test is unused. The JS spec says that RegExp.test should use
+    // RegExp.exec, so it has to store $1 etc.
+    // bool test(const UString &s, int i = -1);
+    uint subPatterns() const { return nrSubPatterns; }
   private:
     const UString &pattern;
     int flags;
+
+#ifndef HAVE_PCREPOSIX
     regex_t preg;
+#else
+    pcre *pcregex;
+#endif
+    uint nrSubPatterns;
 
     RegExp();

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();
+}

trunk/JavaScriptCore/kjs/regexp_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _REGEXP_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
+#include "regexp.h"
 
 namespace KJS {
-
-  class RegExpObject : public ConstructorImp {
+  class ExecState;
+  class RegExpPrototypeImp : public ObjectImp {
   public:
-    RegExpObject(const Object& funcProto, const Object &regProto);
-    Completion execute(const List &);
-    Object construct(const List &);
+    RegExpPrototypeImp(ExecState *exec,
+                       ObjectPrototypeImp *objProto,
+                       FunctionPrototypeImp *funcProto);
   };
 
-  class RegExpPrototype : public ObjectImp {
+  class RegExpProtoFuncImp : public InternalFunctionImp {
   public:
-    RegExpPrototype(const Object& proto);
-    KJSO get(const UString &p) const;
-  };
+    RegExpProtoFuncImp(ExecState *exec,
+                       FunctionPrototypeImp *funcProto, int i, int len);
 
-  class RegExpProtoFunc : public InternalFunctionImp {
-  public:
-    RegExpProtoFunc(int i) : id(i) { }
-    Completion execute(const List &);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
     enum { Exec, Test, ToString };
   private:
@@ -48 +50 @@
   };
 
+  class RegExpImp : public ObjectImp {
+  public:
+    RegExpImp(RegExpPrototypeImp *regexpProto);
+    ~RegExpImp();
+    void setRegExp(RegExp *r) { reg = r; }
+    RegExp* regExp() const { return reg; }
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
+  private:
+    RegExp *reg;
+  };
+
+  class RegExpObjectImp : public InternalFunctionImp {
+  public:
+    RegExpObjectImp(ExecState *exec,
+                    RegExpPrototypeImp *regProto,
+                    FunctionPrototypeImp *funcProto);
+    virtual ~RegExpObjectImp();
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+
+    Value get(ExecState *exec, const UString &p) const;
+    int ** registerRegexp( const RegExp* re, const UString& s );
+    Value arrayOfMatches(ExecState *exec, const UString &result) const;
+  private:
+    UString lastString;
+    int *lastOvector;
+    uint lastNrSubPatterns;
+  };
+
 }; // namespace
 

trunk/JavaScriptCore/kjs/string_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
+ *
  */
 
-#include "kjs.h"
+#include "value.h"
+#include "object.h"
+#include "types.h"
+#include "interpreter.h"
 #include "operations.h"
-#include "types.h"
 #include "regexp.h"
+#include "regexp_object.h"
 #include "string_object.h"
+#include "error_object.h"
 #include <stdio.h>
+#include "string_object.lut.h"
 
 using namespace KJS;
 
-StringObject::StringObject(const Object &funcProto, const Object &stringProto)
-  : ConstructorImp(funcProto, 1)
-{
+// ------------------------------ StringInstanceImp ----------------------------
+
+const ClassInfo StringInstanceImp::info = {"String", 0, 0, 0};
+
+StringInstanceImp::StringInstanceImp(const Object &proto)
+  : ObjectImp(proto)
+{
+  setInternalValue(String(""));
+}
+
+// ------------------------------ StringPrototypeImp ---------------------------
+const ClassInfo StringPrototypeImp::info = {"String", &StringInstanceImp::info, &stringTable, 0};
+/* Source for string_object.lut.h
+@begin stringTable 26
+  toString              StringProtoFuncImp::ToString    DontEnum|Function       0
+  valueOf               StringProtoFuncImp::ValueOf     DontEnum|Function       0
+  charAt                StringProtoFuncImp::CharAt      DontEnum|Function       1
+  charCodeAt            StringProtoFuncImp::CharCodeAt  DontEnum|Function       1
+  concat                StringProtoFuncImp::Concat      DontEnum|Function       1
+  indexOf               StringProtoFuncImp::IndexOf     DontEnum|Function       2
+  lastIndexOf           StringProtoFuncImp::LastIndexOf DontEnum|Function       2
+  match                 StringProtoFuncImp::Match       DontEnum|Function       1
+  replace               StringProtoFuncImp::Replace     DontEnum|Function       2
+  search                StringProtoFuncImp::Search      DontEnum|Function       1
+  slice                 StringProtoFuncImp::Slice       DontEnum|Function       0
+  split                 StringProtoFuncImp::Split       DontEnum|Function       1
+  substr                StringProtoFuncImp::Substr      DontEnum|Function       2
+  substring             StringProtoFuncImp::Substring   DontEnum|Function       2
+  toLowerCase           StringProtoFuncImp::ToLowerCase DontEnum|Function       0
+  toUpperCase           StringProtoFuncImp::ToUpperCase DontEnum|Function       0
+#
+# Under here: html extension, should only exist if KJS_PURE_ECMA is not defined
+# I guess we need to generate two hashtables in the .lut.h file, and use #ifdef
+# to select the right one... TODO. #####
+  big                   StringProtoFuncImp::Big         DontEnum|Function       0
+  small                 StringProtoFuncImp::Small       DontEnum|Function       0
+  blink                 StringProtoFuncImp::Blink       DontEnum|Function       0
+  bold                  StringProtoFuncImp::Bold        DontEnum|Function       0
+  fixed                 StringProtoFuncImp::Fixed       DontEnum|Function       0
+  italics               StringProtoFuncImp::Italics     DontEnum|Function       0
+  strike                StringProtoFuncImp::Strike      DontEnum|Function       0
+  sub                   StringProtoFuncImp::Sub         DontEnum|Function       0
+  sup                   StringProtoFuncImp::Sup         DontEnum|Function       0
+  fontcolor             StringProtoFuncImp::Fontcolor   DontEnum|Function       1
+  fontsize              StringProtoFuncImp::Fontsize    DontEnum|Function       1
+  anchor                StringProtoFuncImp::Anchor      DontEnum|Function       1
+  link                  StringProtoFuncImp::Link        DontEnum|Function       1
+@end
+*/
+// ECMA 15.5.4
+StringPrototypeImp::StringPrototypeImp(ExecState *exec,
+                                       ObjectPrototypeImp *objProto)
+  : StringInstanceImp(Object(objProto))
+{
+  Value protect(this);
+  // The constructor will be added later, after StringObjectImp has been built
+  put(exec,"length",Number(0),DontDelete|ReadOnly|DontEnum);
+
+}
+
+Value StringPrototypeImp::get(ExecState *exec, const UString &propertyName) const
+{
+  return lookupGetFunction<StringProtoFuncImp, StringInstanceImp>( exec, propertyName, &stringTable, this );
+}
+
+// ------------------------------ StringProtoFuncImp ---------------------------
+
+StringProtoFuncImp::StringProtoFuncImp(ExecState *exec, int i, int len)
+  : InternalFunctionImp(
+    static_cast<FunctionPrototypeImp*>(exec->interpreter()->builtinFunctionPrototype().imp())
+    ), id(i)
+{
+  Value protect(this);
+  put(exec,"length",Number(len),DontDelete|ReadOnly|DontEnum);
+}
+
+bool StringProtoFuncImp::implementsCall() const
+{
+  return true;
+}
+
+// ECMA 15.5.4.2 - 15.5.4.20
+Value StringProtoFuncImp::call(ExecState *exec, Object &thisObj, const List &args)
+{
+  Value result;
+
+  // toString and valueOf are no generic function.
+  if (id == ToString || id == ValueOf) {
+    if (thisObj.isNull() || !thisObj.inherits(&StringInstanceImp::info)) {
+      Object err = Error::create(exec,TypeError);
+      exec->setException(err);
+      return err;
+    }
+
+    return String(thisObj.internalValue().toString(exec));
+  }
+
+  int n, m;
+  UString u, u2, u3;
+  int pos, p0, i;
+  double d = 0.0;
+
+  UString s = thisObj.toString(exec);
+
+  int len = s.size();
+  Value a0 = args[0];
+  Value a1 = args[1];
+
+  switch (id) {
+  case ToString:
+  case ValueOf:
+    // handled above
+    break;
+  case CharAt:
+    pos = a0.toInteger(exec);
+    if (pos < 0 || pos >= len)
+      u = "";
+    else
+      u = s.substr(pos, 1);
+    result = String(u);
+    break;
+  case CharCodeAt:
+    pos = a0.toInteger(exec);
+    if (pos < 0 || pos >= len)
+      d = NaN;
+    else {
+      UChar c = s[pos];
+      d = (c.high() << 8) + c.low();
+    }
+    result = Number(d);
+    break;
+  case Concat: {
+    ListIterator it = args.begin();
+    for ( ; it != args.end() ; ++it) {
+        s += it->toString(exec);
+    }
+    result = String(s);
+    break;
+  }
+  case IndexOf:
+    u2 = a0.toString(exec);
+    if (a1.type() == UndefinedType)
+      pos = 0;
+    else
+      pos = a1.toInteger(exec);
+    d = s.find(u2, pos);
+    result = Number(d);
+    break;
+  case LastIndexOf:
+    u2 = a0.toString(exec);
+    d = a1.toNumber(exec);
+    if (a1.type() == UndefinedType || KJS::isNaN(d) || KJS::isPosInf(d))
+      pos = len;
+    else
+      pos = a1.toInteger(exec);
+    if (pos < 0)
+      pos = 0;
+    d = s.rfind(u2, pos);
+    result = Number(d);
+    break;
+  case Match:
+  case Search: {
+    u = s;
+    RegExp* reg = 0;
+    if (a0.isA(ObjectType) && a0.toObject(exec).inherits(&RegExpImp::info))
+    {
+      RegExpImp* imp = static_cast<RegExpImp *>( a0.toObject(exec).imp() );
+      reg = imp->regExp();
+    }
+    else if (a0.isA(StringType))
+    {
+      reg = new RegExp(a0.toString(exec), RegExp::None);
+    }
+    else
+    {
+#ifndef NDEBUG
+      printf("KJS: Match/Search. Argument is not a RegExp nor a String - returning Undefined\n");
+#endif
+      result = Undefined();
+      break;
+    }
+    RegExpObjectImp* regExpObj = static_cast<RegExpObjectImp*>(exec->interpreter()->builtinRegExp().imp());
+    int **ovector = regExpObj->registerRegexp( reg, u );
+    UString mstr = reg->match(u, -1, &pos, ovector);
+    if (a0.isA(StringType))
+      delete reg;
+    if (id == Search) {
+      result = Number(pos);
+      break;
+    }
+    if (mstr.isNull())
+      result = Null();
+    else
+      result = regExpObj->arrayOfMatches(exec,mstr);
+  }
+    break;
+  case Replace:
+    u = s;
+    if (a0.type() == ObjectType && a0.toObject(exec).inherits(&RegExpImp::info)) {
+      RegExpImp* imp = static_cast<RegExpImp *>( a0.toObject(exec).imp() );
+      RegExp *reg = imp->regExp();
+      bool global = false;
+      Value tmp = imp->get(exec,"global");
+      if (tmp.type() != UndefinedType && tmp.toBoolean(exec) == true)
+        global = true;
+
+      RegExpObjectImp* regExpObj = static_cast<RegExpObjectImp*>(exec->interpreter()->builtinRegExp().imp());
+      int **ovector = regExpObj->registerRegexp( reg, u );
+      int lastIndex = 0;
+      u3 = a1.toString(exec); // replacement string
+      // This is either a loop (if global is set) or a one-way (if not).
+      do {
+        UString mstr = reg->match(u, lastIndex, &pos, ovector);
+        len = mstr.size();
+        lastIndex = pos + u3.size();
+        if ( pos != -1 )
+          u = u.substr(0, pos) + u3 + u.substr(pos + len);
+        //fprintf(stderr,"pos=%d,len=%d,lastIndex=%d,u=%s\n",pos,len,lastIndex,u.ascii());
+      } while ( global && pos != -1 );
+
+      result = String(u);
+    } else { // First arg is a string
+      u2 = a0.toString(exec);
+      pos = u.find(u2);
+      len = u2.size();
+      // Do the replacement
+      if (pos == -1)
+        result = String(s);
+      else {
+        u3 = u.substr(0, pos) + a1.toString(exec) +
+             u.substr(pos + len);
+        result = String(u3);
+      }
+    }
+    break;
+  case Slice: // http://developer.netscape.com/docs/manuals/js/client/jsref/string.htm#1194366
+    {
+        // The arg processing is very much like ArrayProtoFunc::Slice
+        // We return a new array
+        result = exec->interpreter()->builtinArray().construct(exec,List::empty());
+        int begin = args[0].toUInt32(exec);
+        int end = len;
+        if (args[1].type() != UndefinedType)
+        {
+          end = args[1].toUInt32(exec);
+          if ( end < 0 )
+            end += len;
+        }
+        // safety tests
+        if ( begin < 0 || end < 0 || begin >= end ) {
+            result = String();
+            break;
+        }
+        //printf( "Slicing from %d to %d \n", begin, end );
+        result = String(s.substr(begin, end-begin));
+        break;
+    }
+    case Split: {
+    Object constructor = exec->interpreter()->builtinArray();
+    Object res = Object::dynamicCast(constructor.construct(exec,List::empty()));
+    result = res;
+    u = s;
+    i = p0 = 0;
+    d = (a1.type() != UndefinedType) ? a1.toInteger(exec) : -1; // optional max number
+    if (a0.type() == ObjectType && Object::dynamicCast(a0).inherits(&RegExpImp::info)) {
+      Object obj0 = Object::dynamicCast(a0);
+      RegExp reg(obj0.get(exec,"source").toString(exec));
+      if (u.isEmpty() && !reg.match(u, 0).isNull()) {
+        // empty string matched by regexp -> empty array
+        res.put(exec,"length", Number(0));
+        break;
+      }
+      int *ovector;
+      int mpos;
+      pos = 0;
+      while (1) {
+        // TODO: back references
+        UString mstr = reg.match(u, pos, &mpos, &ovector);
+        if (mpos < 0)
+          break;
+        pos = mpos + (mstr.isEmpty() ? 1 : mstr.size());
+        if (mpos != p0 || !mstr.isEmpty()) {
+          res.put(exec,UString::from(i), String(u.substr(p0, mpos-p0)));
+          p0 = mpos + mstr.size();
+          i++;
+        }
+      }
+      delete ovector;
+    } else if (a0.type() != UndefinedType) {
+      u2 = a0.toString(exec);
+      if (u2.isEmpty()) {
+        if (u.isEmpty()) {
+          // empty separator matches empty string -> empty array
+          put(exec,"length", Number(0));
+          break;
+        } else {
+          while (i != d && i < u.size()-1)
+            res.put(exec,UString::from(i++), String(u.substr(p0++, 1)));
+        }
+      } else {
+        while (i != d && (pos = u.find(u2, p0)) >= 0) {
+          res.put(exec,UString::from(i), String(u.substr(p0, pos-p0)));
+          p0 = pos + u2.size();
+          i++;
+        }
+      }
+    }
+    // add remaining string, if any
+    if (i != d)
+      res.put(exec,UString::from(i++), String(u.substr(p0)));
+    res.put(exec,"length", Number(i));
+    }
+    break;
+  case Substr: {
+    n = a0.toInteger(exec);
+    m = a1.toInteger(exec);
+    int d, d2;
+    if (n >= 0)
+      d = n;
+    else
+      d = maxInt(len + n, 0);
+    if (a1.type() == UndefinedType)
+      d2 = len - d;
+    else
+      d2 = minInt(maxInt(m, 0), len - d);
+    result = String(s.substr(d, d2));
+    break;
+  }
+  case Substring: {
+    double start = a0.toNumber(exec);
+    double end = a1.toNumber(exec);
+    if (KJS::isNaN(start))
+      start = 0;
+    if (KJS::isNaN(end))
+      end = 0;
+    if (start < 0)
+      start = 0;
+    if (end < 0)
+      end = 0;
+    if (start > len)
+      start = len;
+    if (end > len)
+      end = len;
+    if (a1.type() == UndefinedType)
+      end = len;
+    if (start > end) {
+      double temp = end;
+      end = start;
+      start = temp;
+    }
+    result = String(s.substr((int)start, (int)end-(int)start));
+    }
+    break;
+  case ToLowerCase:
+    u = s;
+    for (i = 0; i < len; i++)
+      u[i] = u[i].toLower();
+    result = String(u);
+    break;
+  case ToUpperCase:
+    u = s;
+    for (i = 0; i < len; i++)
+      u[i] = u[i].toUpper();
+    result = String(u);
+    break;
+#ifndef KJS_PURE_ECMA
+  case Big:
+    result = String("<BIG>" + s + "</BIG>");
+    break;
+  case Small:
+    result = String("<SMALL>" + s + "</SMALL>");
+    break;
+  case Blink:
+    result = String("<BLINK>" + s + "</BLINK>");
+    break;
+  case Bold:
+    result = String("<B>" + s + "</B>");
+    break;
+  case Fixed:
+    result = String("<TT>" + s + "</TT>");
+    break;
+  case Italics:
+    result = String("<I>" + s + "</I>");
+    break;
+  case Strike:
+    result = String("<STRIKE>" + s + "</STRIKE>");
+    break;
+  case Sub:
+    result = String("<SUB>" + s + "</SUB>");
+    break;
+  case Sup:
+    result = String("<SUP>" + s + "</SUP>");
+    break;
+  case Fontcolor:
+    result = String("<FONT COLOR=" + a0.toString(exec) + ">"
+                    + s + "</FONT>");
+    break;
+  case Fontsize:
+    result = String("<FONT SIZE=" + a0.toString(exec) + ">"
+                    + s + "</FONT>");
+    break;
+  case Anchor:
+    result = String("<a name=" + a0.toString(exec) + ">"
+                    + s + "</a>");
+    break;
+  case Link:
+    result = String("<a href=" + a0.toString(exec) + ">"
+                    + s + "</a>");
+    break;
+#endif
+  }
+
+  return result;
+}
+
+// ------------------------------ StringObjectImp ------------------------------
+
+StringObjectImp::StringObjectImp(ExecState *exec,
+                                 FunctionPrototypeImp *funcProto,
+                                 StringPrototypeImp *stringProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
   // ECMA 15.5.3.1 String.prototype
-  setPrototypeProperty(stringProto);
-}
-
-KJSO StringObject::get(const UString &p) const
-{
-  if (p == "fromCharCode")
-    return Function(new StringObjectFunc());
+  put(exec,"prototype", Object(stringProto), DontEnum|DontDelete|ReadOnly);
+
+  put(exec,"fromCharCode", Object(new StringObjectFuncImp(exec,funcProto)), DontEnum);
+
+  // no. of arguments for constructor
+  put(exec,"length", Number(1), ReadOnly|DontDelete|DontEnum);
+}
+
+
+bool StringObjectImp::implementsConstruct() const
+{
+  return true;
+}
+
+// ECMA 15.5.2
+Object StringObjectImp::construct(ExecState *exec, const List &args)
+{
+  Object proto = exec->interpreter()->builtinStringPrototype();
+  Object obj(new StringInstanceImp(proto ));
+
+  UString s;
+  if (args.size() > 0)
+    s = args.begin()->toString(exec);
   else
-    return Imp::get(p);
+    s = UString("");
+
+  obj.setInternalValue(String(s));
+  obj.put(exec, "length", Number(s.size()), ReadOnly|DontEnum|DontDelete);
+
+  return obj;
+}
+
+bool StringObjectImp::implementsCall() const
+{
+  return true;
 }
 
 // ECMA 15.5.1
-Completion StringObject::execute(const List &args)
-{
-  KJSO v;
-  String s;
-
+Value StringObjectImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
   if (args.isEmpty())
-    s = String("");
+    return String("");
   else {
-    v = args[0];
-    s = v.toString();
+    Value v = args[0];
+    return String(v.toString(exec));
   }
-
-  return Completion(ReturnValue, s);
-}
-
-// ECMA 15.5.2
-Object StringObject::construct(const List &args)
-{
-  String s;
-  if (args.size() > 0)
-    s = args.begin()->toString();
-  else
-    s = String("");
-
-  return Object::create(StringClass, s);
-}
+}
+
+// ------------------------------ StringObjectFuncImp --------------------------
 
 // ECMA 15.5.3.2 fromCharCode()
-Completion StringObjectFunc::execute(const List &args)
+StringObjectFuncImp::StringObjectFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto)
+  : InternalFunctionImp(funcProto)
+{
+  Value protect(this);
+  put(exec,"length",Number(1),DontDelete|ReadOnly|DontEnum);
+}
+
+bool StringObjectFuncImp::implementsCall() const
+{
+  return true;
+}
+
+Value StringObjectFuncImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
 {
   UString s;
@@ -79 +529 @@
     ListIterator it = args.begin();
     while (it != args.end()) {
-      unsigned short u = it->toUInt16();
+      unsigned short u = it->toUInt16(exec);
       *p++ = UChar(u);
       it++;
@@ -87 +537 @@
     s = "";
 
-  return Completion(ReturnValue, String(s));
-}
-
-// ECMA 15.5.4
-StringPrototype::StringPrototype(const Object& proto)
-  : ObjectImp(StringClass, String(""), proto)
-{
-  // The constructor will be added later in StringObject's constructor
-}
-
-KJSO StringPrototype::get(const UString &p) const
-{
-  int id;
-
-  if (p == "toString")
-    id = StringProtoFunc::ToString;
-  else if (p == "valueOf")
-    id = StringProtoFunc::ValueOf;
-  else if (p == "charAt")
-    id = StringProtoFunc::CharAt;
-  else if (p == "charCodeAt")
-    id = StringProtoFunc::CharCodeAt;
-  else if (p == "indexOf")
-    id = StringProtoFunc::IndexOf;
-  else if (p == "lastIndexOf")
-    id = StringProtoFunc::LastIndexOf;
-  else if (p == "match")
-    id = StringProtoFunc::Match;
-  else if (p == "replace")
-    id = StringProtoFunc::Replace;
-  else if (p == "search")
-    id = StringProtoFunc::Search;
-  else if (p == "split")
-    id = StringProtoFunc::Split;
-  else if (p == "substr")
-    id = StringProtoFunc::Substr;
-  else if (p == "substring")
-    id = StringProtoFunc::Substring;
-  else if (p == "toLowerCase")
-    id = StringProtoFunc::ToLowerCase;
-  else if (p == "toUpperCase")
-    id = StringProtoFunc::ToUpperCase;
-#ifndef KJS_PURE_ECMA
-  else if (p == "big")
-    id = StringProtoFunc::Big;
-  else if (p == "small")
-    id = StringProtoFunc::Small;
-  else if (p == "blink")
-    id = StringProtoFunc::Blink;
-  else if (p == "bold")
-    id = StringProtoFunc::Bold;
-  else if (p == "fixed")
-    id = StringProtoFunc::Fixed;
-  else if (p == "italics")
-    id = StringProtoFunc::Italics;
-  else if (p == "strike")
-    id = StringProtoFunc::Strike;
-  else if (p == "sub")
-    id = StringProtoFunc::Sub;
-  else if (p == "sup")
-    id = StringProtoFunc::Sup;
-  else if (p == "fontcolor")
-    id = StringProtoFunc::Fontcolor;
-  else if (p == "fontsize")
-    id = StringProtoFunc::Fontsize;
-  else if (p == "anchor")
-    id = StringProtoFunc::Anchor;
-  else if (p == "link")
-    id = StringProtoFunc::Link;
-#endif
-  else
-    return Imp::get(p);
-
-  return Function(new StringProtoFunc(id));
-}
-
-StringProtoFunc::StringProtoFunc(int i)
-  : id(i)
-{
-}
-
-// ECMA 15.5.4.2 - 15.5.4.20
-Completion StringProtoFunc::execute(const List &args)
-{
-  KJSO result;
-
-  Object thisObj = Object::dynamicCast(thisValue());
-
-  // toString and valueOf are no generic function.
-  if (id == ToString || id == ValueOf) {
-    if (thisObj.isNull() || thisObj.getClass() != StringClass) {
-      result = Error::create(TypeError);
-      return Completion(ReturnValue, result);
-    }
-  }
-
-  String s2;
-  Number n, m;
-  UString u, u2, u3;
-  int pos, p0, i;
-  double d, d2;
-  KJSO v = thisObj.internalValue();
-  String s = v.toString();
-  int len = s.value().size();
-  KJSO a0 = args[0];
-  KJSO a1 = args[1];
-
-  switch (id) {
-  case ToString:
-  case ValueOf:
-    result = v.toString();
-    break;
-  case CharAt:
-    n = a0.toInteger();
-    pos = (int) n.value();
-    if (pos < 0 || pos >= len)
-      u = "";
-    else
-      u = s.value().substr(pos, 1);
-    result = String(u);
-    break;
-  case CharCodeAt:
-    n = a0.toInteger();
-    pos = (int) n.value();
-    if (pos < 0 || pos >= len)
-      d = NaN;
-    else {
-      UChar c = s.value()[pos];
-      d = (c.high() << 8) + c.low();
-    }
-    result = Number(d);
-    break;
-  case IndexOf:
-    s2 = a0.toString();
-    if (a1.isA(UndefinedType))
-      pos = 0;
-    else
-      pos = a1.toInteger().intValue();
-    d = s.value().find(s2.value(), pos);
-    result = Number(d);
-    break;
-  case LastIndexOf:
-    s2 = a0.toString();
-    if (a1.isA(UndefinedType))
-      pos = len;
-    else
-      pos = a1.toInteger().intValue();
-    d = s.value().rfind(s2.value(), pos);
-    result = Number(d);
-    break;
-  case Match:
-  case Search:
-    u = s.value();
-    if (a0.isA(ObjectType) && a0.toObject().getClass() == RegExpClass) {
-      s2 = a0.get("source").toString();
-      RegExp reg(s2.value());
-      UString mstr = reg.match(u, -1, &pos);
-      if (id == Search) {
-        result = Number(pos);
-        break;
-      }
-      if (mstr.isNull()) {
-        result = Null();
-        break;
-      }
-      /* TODO return an array, with the matches, etc. */
-      result = String(mstr);
-    } else
-    {
-      printf("Match/Search. Argument is not a RegExp - returning Undefined\n");
-      result = Undefined(); // No idea what to do here
-    }
-    break;
-  case Replace:
-    /* TODO: this is just a hack to get the most common cases going */
-    u = s.value();
-    if (a0.isA(ObjectType) && a0.toObject().getClass() == RegExpClass) {
-      s2 = a0.get("source").toString();
-      RegExp reg(s2.value());
-      UString mstr = reg.match(u, -1, &pos);
-      len = mstr.size();
-    } else {
-      s2 = a0.toString();
-      u2 = s2.value();
-      pos = u.find(u2);
-      len = u2.size();
-    }
-    if (pos == -1)
-        result = s;
-    else {
-        u3 = u.substr(0, pos) + a1.toString().value() +
-             u.substr(pos + len);
-        result = String(u3);
-    }
-    break;
-  case Split:
-    result = Object::create(ArrayClass);
-    u = s.value();
-    i = p0 = 0;
-    d = a1.isDefined() ? a1.toInteger().intValue() : -1; // optional max number
-    if (a0.isA(ObjectType) && Object(a0.imp()).getClass() == RegExpClass) {
-      RegExp reg(a0.get("source").toString().value());
-      if (u.isEmpty() && !reg.match(u, 0).isNull()) {
-        // empty string matched by regexp -> empty array
-        result.put("length", 0);
-        break;
-      }
-      int mpos;
-      pos = 0;
-      while (1) {
-        /* TODO: back references */
-        UString mstr = reg.match(u, pos, &mpos);
-        if (mpos < 0)
-          break;
-        pos = mpos + (mstr.isEmpty() ? 1 : mstr.size());
-        if (mpos != p0 || !mstr.isEmpty()) {
-          result.put(UString::from(i), String(u.substr(p0, mpos-p0)));
-          p0 = mpos + mstr.size();
-          i++;
-        }
-      }
-    } else if (a0.isDefined()) {
-      u2 = a0.toString().value();
-      if (u2.isEmpty()) {
-        if (u.isEmpty()) {
-          // empty separator matches empty string -> empty array
-          put("length", 0);
-          break;
-        } else {
-          while (i != d && i < u.size())
-            result.put(UString::from(i++), String(u.substr(p0++, 1)));
-        }
-      } else {
-        while (i != d && (pos = u.find(u2, p0)) >= 0) {
-          result.put(UString::from(i), String(u.substr(p0, pos-p0)));
-          p0 = pos + u2.size();
-          i++;
-        }
-      }
-    }
-    // add remaining string, if any
-    if (i != d && (p0 < len || i == 0))
-      result.put(UString::from(i++), String(u.substr(p0)));
-    result.put("length", i);
-    break;
-  case Substr:
-    n = a0.toInteger();
-    m = a1.toInteger();
-    if (n.value() >= 0)
-      d = n.value();
-    else
-      d = max(len + n.value(), 0);
-    if (a1.isA(UndefinedType))
-      d2 = len - d;
-    else
-      d2 = min(max(m.value(), 0), len - d);
-    result = String(s.value().substr((int)d, (int)d2));
-    break;
-  case Substring:
-    n = a0.toInteger();
-    m = a1.toInteger();
-    d = min(max(n.value(), 0), len);
-    if (a1.isA(UndefinedType))
-      d2 = len - d;
-    else {
-      d2 = min(max(m.value(), 0), len);
-      d2 = max(d2-d, 0);
-    }
-    result = String(s.value().substr((int)d, (int)d2));
-    break;
-  case ToLowerCase:
-    u = UString(s.value());
-    for (i = 0; i < len; i++)
-      u[i] = u[i].toLower();
-    result = String(u);
-    break;
-  case ToUpperCase:
-    u = UString(s.value());
-    for (i = 0; i < len; i++)
-      u[i] = u[i].toUpper();
-    result = String(u);
-    break;
-#ifndef KJS_PURE_ECMA
-  case Big:
-    result = String("<BIG>" + s.value() + "</BIG>");
-    break;
-  case Small:
-    result = String("<SMALL>" + s.value() + "</SMALL>");
-    break;
-  case Blink:
-    result = String("<BLINK>" + s.value() + "</BLINK>");
-    break;
-  case Bold:
-    result = String("<B>" + s.value() + "</B>");
-    break;
-  case Fixed:
-    result = String("<TT>" + s.value() + "</TT>");
-    break;
-  case Italics:
-    result = String("<I>" + s.value() + "</I>");
-    break;
-  case Strike:
-    result = String("<STRIKE>" + s.value() + "</STRIKE>");
-    break;
-  case Sub:
-    result = String("<SUB>" + s.value() + "</SUB>");
-    break;
-  case Sup:
-    result = String("<SUP>" + s.value() + "</SUP>");
-    break;
-  case Fontcolor:
-    result = String("<FONT COLOR=" + a0.toString().value() + ">"
-                    + s.value() + "</FONT>");
-    break;
-  case Fontsize:
-    result = String("<FONT SIZE=" + a0.toString().value() + ">"
-                    + s.value() + "</FONT>");
-    break;
-  case Anchor:
-    result = String("<a name=" + a0.toString().value() + ">"
-                    + s.value() + "</a>");
-    break;
-  case Link:
-    result = String("<a href=" + a0.toString().value() + ">"
-                    + s.value() + "</a>");
-    break;
-#endif
-  }
-
-  return Completion(ReturnValue, result);
-}
+  return String(s);
+}

trunk/JavaScriptCore/kjs/string_object.h

@@ +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$
  */
 
@@ -21 +24 @@
 #define _STRING_OBJECT_H_
 
-#include "object.h"
-#include "function.h"
+#include "internal.h"
+#include "function_object.h"
 
 namespace KJS {
 
-  class StringObject : public ConstructorImp {
+  class StringInstanceImp : public ObjectImp {
   public:
-    StringObject(const Object &funcProto, const Object &stringProto);
-    KJSO get(const UString &p) const;
-    Completion execute(const List &);
-    Object construct(const List &);
+    StringInstanceImp(const Object &proto);
+
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   };
 
-  class StringObjectFunc : public InternalFunctionImp {
+  /**
+   * @internal
+   *
+   * The initial value of String.prototype (and thus all objects created
+   * with the String constructor
+   */
+  class StringPrototypeImp : public StringInstanceImp {
   public:
-    Completion execute(const List &);
+    StringPrototypeImp(ExecState *exec,
+                       ObjectPrototypeImp *objProto);
+    Value get(ExecState *exec, const UString &p) const;
+    virtual const ClassInfo *classInfo() const { return &info; }
+    static const ClassInfo info;
   };
 
-  class StringPrototype : public ObjectImp {
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * String.prototype object
+   */
+  class StringProtoFuncImp : public InternalFunctionImp {
   public:
-    StringPrototype(const Object& proto);
-    KJSO get(const UString &p) const;
-  };
+    StringProtoFuncImp(ExecState *exec, int i, int len);
 
-  class StringProtoFunc : public InternalFunctionImp {
-  public:
-    StringProtoFunc(int i);
-    Completion execute(const List &);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
 
-    enum { ToString, ValueOf, CharAt, CharCodeAt, IndexOf, LastIndexOf,
+    enum { ToString, ValueOf, CharAt, CharCodeAt, Concat, IndexOf, LastIndexOf,
            Match, Replace, Search, Slice, Split,
            Substr, Substring, FromCharCode, ToLowerCase, ToUpperCase
@@ -62 +77 @@
   };
 
+  /**
+   * @internal
+   *
+   * The initial value of the the global variable's "String" property
+   */
+  class StringObjectImp : public InternalFunctionImp {
+  public:
+    StringObjectImp(ExecState *exec,
+                    FunctionPrototypeImp *funcProto,
+                    StringPrototypeImp *stringProto);
+
+    virtual bool implementsConstruct() const;
+    virtual Object construct(ExecState *exec, const List &args);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+  };
+
+  /**
+   * @internal
+   *
+   * Class to implement all methods that are properties of the
+   * String object
+   */
+  class StringObjectFuncImp : public InternalFunctionImp {
+  public:
+    StringObjectFuncImp(ExecState *exec, FunctionPrototypeImp *funcProto);
+    virtual bool implementsCall() const;
+    virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+  };
+
 }; // namespace
 
 #endif
+

trunk/JavaScriptCore/kjs/testkjs.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
 #include <stdio.h>
+#include <iostream.h>
 
-#include "kjs.h"
-
+#include "value.h"
 #include "object.h"
 #include "types.h"
-#include "internal.h"
+#include "interpreter.h"
+
+using namespace KJS;
+
+class TestFunctionImp : public ObjectImp {
+public:
+  TestFunctionImp() : ObjectImp() {}
+  virtual bool implementsCall() const { return true; }
+  virtual Value call(ExecState *exec, Object &thisObj, const List &args);
+};
+
+Value TestFunctionImp::call(ExecState *exec, Object &/*thisObj*/, const List &args)
+{
+  fprintf(stderr,"--> %s\n",args[0].toString(exec).ascii());
+  return Undefined();
+}
+
+class GlobalImp : public ObjectImp {
+public:
+  virtual UString className() const { return "global"; }
+};
 
 int main(int argc, char **argv)
@@ -35 +58 @@
   }
 
-  // create interpreter
-  KJScript *kjs = new KJScript();
+  bool ret = true;
+  {
+    Object global(new GlobalImp());
 
-  // add debug() function
-  kjs->enableDebug();
+    // create interpreter
+    Interpreter interp(global);
+    global.put(interp.globalExec(),"debug", Object(new TestFunctionImp()));
+    // add "print" for compatibility with the mozilla js shell
+    global.put(interp.globalExec(),"print", Object(new TestFunctionImp()));
 
-  const int BufferSize = 100000;
-  char code[BufferSize];
+    // add debug() function
+    //  kjs->enableDebug();
 
-  bool ret = true;
-  for (int i = 1; i < argc; i++) {
-    const char *file = argv[i];
-    FILE *f = fopen(file, "r");
-    if (!f) {
-      fprintf(stderr, "Error opening %s.\n", file);
-      return -1;
+    const int BufferSize = 200000;
+    char code[BufferSize];
+
+    for (int i = 1; i < argc; i++) {
+      const char *file = argv[i];
+      FILE *f = fopen(file, "r");
+      if (!f) {
+        fprintf(stderr, "Error opening %s.\n", file);
+        return -1;
+      }
+      int num = fread(code, 1, BufferSize, f);
+      code[num] = '\0';
+      if(num >= BufferSize)
+        fprintf(stderr, "Warning: File may have been too long.\n");
+
+      // run
+      Completion comp(interp.evaluate(code));
+
+      fclose(f);
+
+      if (comp.complType() == Throw) {
+        ExecState *exec = interp.globalExec();
+        Value exVal = comp.value();
+        char *msg = exVal.toString(exec).ascii();
+        int lineno = -1;
+        if (exVal.type() == ObjectType) {
+          Value lineVal = Object::dynamicCast(exVal).get(exec,"line");
+          if (lineVal.type() == NumberType)
+            lineno = int(lineVal.toNumber(exec));
+        }
+        if (lineno != -1)
+          fprintf(stderr,"Exception, line %d: %s\n",lineno,msg);
+        else
+          fprintf(stderr,"Exception: %s\n",msg);
+        ret = false;
+      }
+      else if (comp.complType() == ReturnValue) {
+        char *msg = comp.value().toString(interp.globalExec()).ascii();
+        fprintf(stderr,"Return value: %s\n",msg);
+      }
     }
-    int num = fread(code, 1, BufferSize, f);
-    code[num] = '\0';
-    if(num >= BufferSize)
-      fprintf(stderr, "Warning: File may have been too long.\n");
 
-    // run
-    ret = ret && kjs->evaluate(code);
-    if (kjs->errorType() != 0)
-      printf("%s returned: %s\n", file, kjs->errorMsg());
-    else if (kjs->returnValue())
-      printf("returned a value\n");
+    //  delete kjs;
+  } // end block, so that Interpreter and global get deleted
 
-    fclose(f);
-  }
-
-  delete kjs;
+  if (ret)
+    fprintf(stderr, "OK.\n");
 
 #ifdef KJS_DEBUG_MEM
-  printf("List::count = %d\n", KJS::List::count);
-  assert(KJS::List::count == 0);
-  printf("Imp::count = %d\n", KJS::Imp::count);
-  assert(KJS::Imp::count == 0);
+  Interpreter::finalCheck();
 #endif
-
-  fprintf(stderr, "OK.\n");
   return ret;
 }

trunk/JavaScriptCore/kjs/types.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  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 <assert.h>
+#include <math.h>
+#include <stdio.h>
+
 #include "internal.h"
+#include "collector.h"
 #include "operations.h"
+#include "error_object.h"
 #include "nodes.h"
 
 using namespace KJS;
 
-Undefined::Undefined() : KJSO(UndefinedImp::staticUndefined) { }
-
-Undefined::~Undefined() { }
-
-Null::Null() : KJSO(NullImp::staticNull) { }
-
-Null::~Null() { }
-
-Boolean::Boolean(bool b)
-  : KJSO(b ? BooleanImp::staticTrue : BooleanImp::staticFalse)
-{
-}
-
-Boolean::Boolean(BooleanImp *i) : KJSO(i) { }
-
-Boolean::~Boolean() { }
-
-bool Boolean::value() const
-{
-  assert(rep);
-  return ((BooleanImp*)rep)->value();
-}
-
-Number::Number(int i)
-  : KJSO(new NumberImp(static_cast<double>(i))) { }
-
-Number::Number(unsigned int u)
-  : KJSO(new NumberImp(static_cast<double>(u))) { }
-
-Number::Number(double d)
-  : KJSO(new NumberImp(d)) { }
-
-Number::Number(long int l)
-  : KJSO(new NumberImp(static_cast<double>(l))) { }
-
-Number::Number(long unsigned int l)
-  : KJSO(new NumberImp(static_cast<double>(l))) { }
-
-Number::Number(NumberImp *i)
-  : KJSO(i) { }
-
-Number::~Number() { }
-
-double Number::value() const
-{
-  assert(rep);
-  return ((NumberImp*)rep)->value();
-}
-
-int Number::intValue() const
-{
-  assert(rep);
-  return (int)((NumberImp*)rep)->value();
-}
-
-bool Number::isNaN() const
-{
-  return KJS::isNaN(((NumberImp*)rep)->value());
-}
-
-bool Number::isInf() const
-{
-  return KJS::isInf(((NumberImp*)rep)->value());
-}
-
-String::String(const UString &s) : KJSO(new StringImp(UString(s))) { }
-
-String::String(StringImp *i) : KJSO(i) { }
-
-String::~String() { }
-
-UString String::value() const
-{
-  assert(rep);
-  return ((StringImp*)rep)->value();
-}
-
-Reference::Reference(const KJSO& b, const UString &p)
-  : KJSO(new ReferenceImp(b, p))
+// ------------------------------ Reference ------------------------------------
+
+Reference::Reference(const Object& b, const UString& p)
+  : Value(new ReferenceImp(b,p))
+{
+}
+
+Reference::Reference(const Null& b, const UString& p)
+  : Value(new ReferenceImp(b,p))
+{
+}
+
+Reference::Reference(ReferenceImp *v) : Value(v)
+{
+}
+
+Reference::Reference(const Reference &v) : Value(v)
 {
 }
@@ -116 +64 @@
 }
 
-Completion::Completion(Imp *d) : KJSO(d) { }
-
-Completion::Completion(Compl c)
-  : KJSO(new CompletionImp(c, KJSO(), UString::null))
-{
-  if (c == Throw)
-    KJScriptImp::setException(new UndefinedImp());
-}
-
-Completion::Completion(Compl c, const KJSO& v, const UString &t)
-  : KJSO(new CompletionImp(c, v, t))
-{
-  if (c == Throw)
-    KJScriptImp::setException(v.imp());
-}
-
-Completion::~Completion() { }
-
-Compl Completion::complType() const
-{
-  assert(rep);
-  return ((CompletionImp*)rep)->completion();
+Reference& Reference::operator=(const Reference &v)
+{
+  Value::operator=(v);
+  return *this;
+}
+
+Reference Reference::dynamicCast(const Value &v)
+{
+  if (v.isNull() || v.type() != ReferenceType)
+    return 0;
+
+  return static_cast<ReferenceImp*>(v.imp());
+}
+
+// ------------------------------ ListIterator ---------------------------------
+
+//d  dont add   ListIterator();
+
+ListIterator::ListIterator(ListNode *n) : node(n)
+{
+}
+
+ListIterator::ListIterator(const List &l)
+  : node(static_cast<ListImp*>(l.imp())->hook->next)
+{
+}
+
+ListIterator& ListIterator::operator=(const ListIterator &iterator)
+{
+  node=iterator.node;
+  return *this;
+}
+
+ListIterator::ListIterator(const ListIterator &i) : node(i.node)
+{
+}
+
+ListIterator::~ListIterator()
+{
+}
+
+ValueImp* ListIterator::operator->() const
+{
+  return node->member;
+}
+
+    //    operator Value* () const { return node->member; }
+Value ListIterator::operator*() const
+{
+  return Value(node->member);
+}
+
+    //    operator Value*() const { return node->member; }
+Value ListIterator::operator++()
+{
+  node = node->next;
+  return Value(node->member);
+}
+
+Value ListIterator::operator++(int)
+{
+  const ListNode *n = node;
+  ++*this;
+  return Value(n->member);
+}
+
+Value ListIterator::operator--()
+{
+  node = node->prev;
+  return Value(node->member);
+}
+
+Value ListIterator::operator--(int)
+{
+  const ListNode *n = node;
+  --*this;
+  return Value(n->member);
+}
+
+bool ListIterator::operator==(const ListIterator &it) const
+{
+  return (node==it.node);
+}
+
+bool ListIterator::operator!=(const ListIterator &it) const
+{
+  return (node!=it.node);
+}
+
+// ------------------------------ List -----------------------------------------
+
+List::List()
+  : Value(new ListImp())
+{
+  //fprintf(stderr,"List::List() this=%p imp=%p refcount=%d\n",this,rep,rep->refcount);
+}
+
+List::List(ListImp *v) : Value(v)
+{
+  //fprintf(stderr,"List::List(imp) this=%p imp=%p refcount=%d\n",this,v,v?v->refcount:0);
+}
+
+List::List(const List &v) : Value(v)
+{
+  //fprintf(stderr,"List::List(List) this=%p imp=%p refcount=%d\n",this,rep,rep?rep->refcount:0);
+}
+
+List::~List()
+{
+  //fprintf(stderr,"List::~List() this=%p imp=%p refcount=%d\n",this,rep,rep->refcount-1);
+}
+
+List& List::operator=(const List &v)
+{
+  //fprintf(stderr,"List::operator=() this=%p\n",this);
+  Value::operator=(v);
+  return *this;
+}
+
+List List::dynamicCast(const Value &v)
+{
+  if (v.isNull() || v.type() != ListType)
+    return 0;
+
+  return static_cast<ListImp*>(v.imp());
+}
+
+void List::append(const Value& val)
+{
+  static_cast<ListImp*>(rep)->append(val);
+}
+
+void List::prepend(const Value& val)
+{
+  static_cast<ListImp*>(rep)->prepend(val);
+}
+
+void List::appendList(const List& lst)
+{
+  static_cast<ListImp*>(rep)->appendList(lst);
+}
+
+void List::prependList(const List& lst)
+{
+  static_cast<ListImp*>(rep)->prependList(lst);
+}
+
+void List::removeFirst()
+{
+  static_cast<ListImp*>(rep)->removeFirst();
+}
+
+void List::removeLast()
+{
+  static_cast<ListImp*>(rep)->removeLast();
+}
+
+void List::remove(const Value &val)
+{
+  static_cast<ListImp*>(rep)->remove(val);
+}
+
+void List::clear()
+{
+  static_cast<ListImp*>(rep)->clear();
+}
+
+List List::copy() const
+{
+  return static_cast<ListImp*>(rep)->copy();
+}
+
+ListIterator List::begin() const
+{
+  return static_cast<ListImp*>(rep)->begin();
+}
+
+ListIterator List::end() const
+{
+  return static_cast<ListImp*>(rep)->end();
+}
+
+bool List::isEmpty() const
+{
+  return static_cast<ListImp*>(rep)->isEmpty();
+}
+
+int List::size() const
+{
+  return static_cast<ListImp*>(rep)->size();
+}
+
+Value List::at(int i) const
+{
+  return static_cast<ListImp*>(rep)->at(i);
+}
+
+Value List::operator[](int i) const
+{
+  return static_cast<ListImp*>(rep)->at(i);
+}
+
+const List List::empty()
+{
+  return ListImp::empty();
+}
+
+// ------------------------------ Completion -----------------------------------
+
+Completion::Completion(ComplType c, const Value& v, const UString &t)
+  : Value(new CompletionImp(c,v,t))
+{
+}
+
+Completion::Completion(CompletionImp *v) : Value(v)
+{
+}
+
+Completion::Completion(const Completion &v) : Value(v)
+{
+}
+
+Completion::~Completion()
+{
+}
+
+Completion& Completion::operator=(const Completion &v)
+{
+  Value::operator=(v);
+  return *this;
+}
+
+Completion Completion::dynamicCast(const Value &v)
+{
+  if (v.isNull() || v.type() != CompletionType)
+    return 0;
+
+  return static_cast<CompletionImp*>(v.imp());
+}
+
+ComplType Completion::complType() const
+{
+  return static_cast<CompletionImp*>(rep)->complType();
+}
+
+Value Completion::value() const
+{
+  return static_cast<CompletionImp*>(rep)->value();
+}
+
+UString Completion::target() const
+{
+  return static_cast<CompletionImp*>(rep)->target();
 }
 
 bool Completion::isValueCompletion() const
 {
-  assert(rep);
-  return !((CompletionImp*)rep)->value().isNull();
-}
-
-KJSO Completion::value() const
-{
-  assert(isA(CompletionType));
-  return ((CompletionImp*)rep)->value();
-}
-
-UString Completion::target() const
-{
-  assert(rep);
-  return ((CompletionImp*)rep)->target();
-}
-
-ListIterator::ListIterator(const List &l)
-  : node(l.hook->next)
-{
-}
-
-List::List()
-{
-#ifdef KJS_DEBUG_MEM
-  count++;
-#endif
-
-  static KJSO *null = 0;
-  if (!null)
-     null = new KJSO();
-
-  hook = new ListNode(*null, 0L, 0L);
-  hook->next = hook;
-  hook->prev = hook;
-}
-
-List::~List()
-{
-#ifdef KJS_DEBUG_MEM
-  count--;
-#endif
-
-  clear();
-  delete hook;
-}
-
-void List::append(const KJSO& obj)
-{
-  ListNode *n = new ListNode(obj, hook->prev, hook);
-  hook->prev->next = n;
-  hook->prev = n;
-}
-
-void List::prepend(const KJSO& obj)
-{
-  ListNode *n = new ListNode(obj, hook, hook->next);
-  hook->next->prev = n;
-  hook->next = n;
-}
-
-void List::removeFirst()
-{
-  erase(hook->next);
-}
-
-void List::removeLast()
-{
-  erase(hook->prev);
-}
-
-void List::remove(const KJSO &obj)
-{
-  if (obj.isNull())
-    return;
-  ListNode *n = hook->next;
-  while (n != hook) {
-    if (n->member.imp() == obj.imp()) {
-      erase(n);
-      return;
-    }
-    n = n->next;
-  }
-}
-
-void List::clear()
-{
-  ListNode *n = hook->next;
-  while (n != hook) {
-    n = n->next;
-    delete n->prev;
-  }
-
-  hook->next = hook;
-  hook->prev = hook;
-}
-
-List *List::copy() const
-{
-  List *newList = new List();
-  ListIterator e = end();
-  ListIterator it = begin();
-
-  while(it != e) {
-    newList->append(*it);
-    ++it;
-  }
-
-  return newList;
-}
-
-void List::erase(ListNode *n)
-{
-  if (n != hook) {
-    n->next->prev = n->prev;
-    n->prev->next = n->next;
-    delete n;
-  }
-}
-
-int List::size() const
-{
-  int s = 0;
-  ListNode *node = hook;
-  while ((node = node->next) != hook)
-    s++;
-
-  return s;
-}
-
-KJSO List::at(int i) const
-{
-  if (i < 0 || i >= size())
-    return Undefined();
-
-  ListIterator it = begin();
-  int j = 0;
-  while ((j++ < i))
-    it++;
-
-  return *it;
-}
-
-List *List::emptyList = 0L;
-
-const List *List::empty()
-{
-  if (!emptyList)
-    emptyList = new List;
-#ifdef KJS_DEBUG_MEM
-  else
-    count++;
-#endif
-
-
-  return emptyList;
-}
+  return !value().isNull();
+}

trunk/JavaScriptCore/kjs/types.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
- *  Copyright (C) 1999-2000 Harri Porten ([email protected])
+ *  Copyright (C) 1999-2001 Harri Porten ([email protected])
+ *  Copyright (C) 2001 Peter Kelly ([email protected])
  *
  *  This library is free software; you can redistribute it and/or
@@ -17 +19 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
-#ifndef _TYPES_H_
-#define _TYPES_H_
-
-#include "object.h"
+#ifndef _KJS_TYPES_H_
+#define _KJS_TYPES_H_
+
+// internal data types
+
+#include "value.h"
 
 namespace KJS {
 
-  /**
-   * @short Handle for an Undefined type.
-   */
-  class Undefined : public KJSO {
-  public:
-    Undefined();
-    virtual ~Undefined();
-  };
-
-  /**
-   * @short Handle for a Null type.
-   */
-  class Null : public KJSO {
-  public:
-    Null();
-    virtual ~Null();
-  };
-
-  class BooleanImp;
-  class NumberImp;
-  class StringImp;
-
-  /**
-   * @short Handle for a Boolean type.
-   */
-  class Boolean : public KJSO {
-    friend class BooleanImp;
-  public:
-    Boolean(bool b = false);
-    virtual ~Boolean();
-    bool value() const;
-  private:
-    Boolean(BooleanImp *i);
-  };
-
-  /**
-   * @short Handle for a Number type.
-   *
-   * Number is a handle for a number value. @ref KJSO::toPrimitive(),
-   * @ref KJSO::toBoolean(), @ref KJSO::toNumber(), @ref KJSO::toString() and
-   * @ref KJSO::toString() are re-implemented internally according to the
-   * specification.
-   *
-   * Example usage:
-   * <pre>
-   * Number a(2), b(3.0), c; // c defaults to 0.0
-   *
-   * c = a.value() * b.value(); // c will be 6.0 now
-   *
-   * String s = c.toString(); // s holds "6"
-   * </pre>
-   *
-   * Note the following implementation detail: Internally, the value is stored
-   * as a double and will be casted from and to other types when needed.
-   * This won't be noticable within a certain range of values but might produce
-   * unpredictable results when crossing these limits. In case this turns out
-   * to be a real problem for an application we might have to extend this class
-   * to behave more intelligently.
-   */
-  class Number : public KJSO {
-    friend class NumberImp;
-  public:
-    /**
-     * Construct a Number type from an integer.
-     */
-    Number(int i);
-    /**
-     * Construct a Number type from an unsigned integer.
-     */
-    Number(unsigned int u);
-    /**
-     * Construct a Number type from a double.
-     */
-    Number(double d = 0.0);
-    /**
-     * Construct a Number type from a long int.
-     */
-    Number(long int l);
-    /**
-     * Construct a Number type from a long unsigned int.
-     */
-    Number(long unsigned int l);
-    /**
-     * Destructor.
-     */
-    virtual ~Number();
-    /**
-     * @return The internally stored value.
-     */
-    double value() const;
-    /**
-     * Convenience function.
-     * @return The internally stored value converted to an int.
-     */
-    int intValue() const;
-    /**
-     * @return True is this is not a number (NaN).
-     */
-    bool isNaN() const;
-    /**
-     * @return True if Number is either +Infinity or -Infinity.
-     */
-    bool isInf() const;
-  private:
-    Number(NumberImp *i);
-  };
-
-  /**
-   * @short Handle for a String type.
-   */
-  class String : public KJSO {
-    friend class StringImp;
-  public:
-    String(const UString &s = "");
-    virtual ~String();
-    UString value() const;
-  private:
-    String(StringImp *i);
-  };
-
-  /**
-   * Completion objects are used to convey the return status and value
-   * from functions.
-   *
-   * See @ref FunctionImp::execute()
-   *
-   * @see FunctionImp
-   *
-   * @short Handle for a Completion type.
-   */
-  class Completion : public KJSO {
-  public:
-    Completion(Imp *d = 0L);
-    Completion(Compl c);
-    Completion(Compl c, const KJSO& v, const UString &t = UString::null);
-    virtual ~Completion();
-    Compl complType() const;
-    bool isValueCompletion() const;
-    KJSO value() const;
-    UString target() const;
+  class Reference : public Value {
+  public:
+    Reference(const Object& b, const UString& p);
+    Reference(const Null& b, const UString& p);
+    Reference(ReferenceImp *v);
+    Reference(const Reference &v);
+    virtual ~Reference();
+
+    Reference& operator=(const Reference &v);
+
+    /**
+     * Converts a Value into an Reference. If the value's type is not
+     * ReferenceType, a null object will be returned (i.e. one with it's
+     * internal pointer set to 0). If you do not know for sure whether the
+     * value is of type ReferenceType, you should check the @ref isNull()
+     * methods afterwards before calling any methods on the returned value.
+     *
+     * @return The value converted to an Reference
+     */
+    static Reference dynamicCast(const Value &v);
   };
 
   class List;
   class ListIterator;
-
-  /**
-   * @internal
-   */
-  class ListNode {
-    friend class List;
-    friend class ListIterator;
-    ListNode(KJSO obj, ListNode *p, ListNode *n)
-      : member(obj), prev(p), next(n) {};
-    KJSO member;
-    ListNode *prev, *next;
-  };
+  class ListNode;
 
   /**
@@ -188 +63 @@
   class ListIterator {
     friend class List;
+    friend class ListImp;
     ListIterator();
-    ListIterator(ListNode *n) : node(n) { }
+    ListIterator(ListNode *n);
   public:
     /**
@@ -195 +71 @@
      * @param l The list the iterator will operate on.
      */
-    ListIterator(const List &list);
+    ListIterator(const List &l);
     /**
      * Assignment constructor.
      */
-    ListIterator& operator=(const ListIterator &iterator)
-      { node=iterator.node; return *this; }
+    ListIterator& operator=(const ListIterator &iterator);
     /**
      * Copy constructor.
      */
-    ListIterator(const ListIterator &i) : node(i.node) { }
+    ListIterator(const ListIterator &i);
+    ~ListIterator();
     /**
      * Dereference the iterator.
      * @return A pointer to the element the iterator operates on.
      */
-    KJSO* operator->() const { return &node->member; }
-    //    operator KJSO* () const { return node->member; }
-    KJSO operator*() const { return node->member; }
-    /**
-     * Conversion to @ref KJS::KJSO*
+    ValueImp* operator->() const;
+    //    operator Value* () const { return node->member; }
+    Value operator*() const;
+    /**
+     * Conversion to @ref KJS::Value*
      * @return A pointer to the element the iterator operates on.
      */
-    //    operator KJSO*() const { return node->member; }
+    //    operator Value*() const { return node->member; }
     /**
      * Postfix increment operator.
      * @return The element after the increment.
      */
-    KJSO operator++() { node = node->next; return node->member; }
+    Value operator++();
     /**
      * Prefix increment operator.
      */
-    KJSO operator++(int) { const ListNode *n = node; ++*this; return n->member; }
+    Value operator++(int);
     /**
      * Postfix decrement operator.
      */
-    KJSO operator--() { node = node->prev; return node->member; }
+    Value operator--();
     /**
      * Prefix decrement operator.
      */
-    KJSO operator--(int) { const ListNode *n = node; --*this; return n->member; }
+    Value operator--(int);
     /**
      * Compare the iterator with another one.
@@ -239 +115 @@
      * False otherwise.
      */
-    bool operator==(const ListIterator &it) const { return (node==it.node); }
+    bool operator==(const ListIterator &it) const;
     /**
      * Check for inequality with another iterator.
      * @return True if the two iterators operate on different list elements.
      */
-    bool operator!=(const ListIterator &it) const { return (node!=it.node); }
+    bool operator!=(const ListIterator &it) const;
   private:
     ListNode *node;
@@ -259 +135 @@
    * copy of the list the referenced objects are still shared.
    */
-  class List {
+  class List : public Value {
     friend class ListIterator;
   public:
-    /**
-     * Constructor.
-     */
     List();
-    /**
-     * Destructor.
-     */
-    ~List();
+    List(ListImp *v);
+    List(const List &v);
+    virtual ~List();
+
+    List& operator=(const List &v);
+
+    /**
+     * Converts a Value into an List. If the value's type is not
+     * ListType, a null object will be returned (i.e. one with it's
+     * internal pointer set to 0). If you do not know for sure whether the
+     * value is of type List, you should check the @ref isNull()
+     * methods afterwards before calling any methods on the returned value.
+     *
+     * @return The value converted to an List
+     */
+    static List dynamicCast(const Value &v);
     /**
      * Append an object to the end of the list.
      *
-     * @param obj Pointer to object.
-     */
-    void append(const KJSO& obj);
+     * @param val Pointer to object.
+     */
+    void append(const Value& val);
     /**
      * Insert an object at the beginning of the list.
      *
-     * @param obj Pointer to object.
-     */
-    void prepend(const KJSO& obj);
+     * @param val Pointer to object.
+     */
+    void prepend(const Value& val);
+    /**
+     * Appends the items of another list at the end of this one.
+     */
+    void appendList(const List& lst);
+    /**
+     * Prepend the items of another list to this one.
+     * The first item of @p lst will become the first item of the list.
+     */
+    void prependList(const List& lst);
     /**
      * Remove the element at the beginning of the list.
@@ -291 +185 @@
     void removeLast();
     /*
-     * Remove obj from list.
-     */
-    void remove(const KJSO &obj);
+     * Remove val from list.
+     */
+    void remove(const Value &val);
     /**
      * Remove all elements from the list.
@@ -302 +196 @@
      * who is responsible for deleting the list then.
      */
-    List *copy() const;
+    List copy() const;
     /**
      * @return A @ref KJS::ListIterator pointing to the first element.
      */
-    ListIterator begin() const { return ListIterator(hook->next); }
+    ListIterator begin() const;
     /**
      * @return A @ref KJS::ListIterator pointing to the last element.
      */
-    ListIterator end() const { return ListIterator(hook); }
+    ListIterator end() const;
     /**
      * @return true if the list is empty. false otherwise.
      */
-    bool isEmpty() const { return (hook->prev == hook); }
+    bool isEmpty() const;
     /**
      * @return the current size of the list.
@@ -327 +221 @@
      * index is out of range.
      */
-    KJSO at(int i) const;
+    Value at(int i) const;
     /**
      * Equivalent to @ref at.
      */
-    KJSO operator[](int i) const { return at(i); }
+    Value operator[](int i) const;
     /**
      * Returns a pointer to a static instance of an empty list. Useful if a
      * function has a @ref KJS::List parameter.
      */
-    static const List *empty();
-
-#ifdef KJS_DEBUG_MEM
-    /**
-     * @internal
-     */
-    static int count;
-#endif
-  private:
-    void erase(ListNode *n);
-    ListNode *hook;
-    static List *emptyList;
+    static const List empty();
+  };
+
+  /**
+   * Completion types.
+   */
+  enum ComplType { Normal, Break, Continue, ReturnValue, Throw };
+
+  /**
+   * Completion objects are used to convey the return status and value
+   * from functions.
+   *
+   * See @ref FunctionImp::execute()
+   *
+   * @see FunctionImp
+   *
+   * @short Handle for a Completion type.
+   */
+  class Completion : public Value {
+  public:
+    Completion(ComplType c = Normal, const Value& v = Value(),
+               const UString &t = UString::null);
+    Completion(CompletionImp *v);
+    Completion(const Completion &v);
+    virtual ~Completion();
+
+    Completion& operator=(const Completion &v);
+
+    /**
+     * Converts a Value into an Completion. If the value's type is not
+     * CompletionType, a null object will be returned (i.e. one with it's
+     * internal pointer set to 0). If you do not know for sure whether the
+     * value is of type CompletionType, you should check the @ref isNull()
+     * methods afterwards before calling any methods on the returned value.
+     *
+     * @return The value converted to an Completion
+     */
+    static Completion dynamicCast(const Value &v);
+
+    ComplType complType() const;
+    Value value() const;
+    UString target() const;
+    bool isValueCompletion() const;
   };
 
 }; // namespace
 
-
-#endif
+#endif // _KJS_TYPES_H_

trunk/JavaScriptCore/kjs/ustring.cpp

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
@@ -35 +38 @@
 #include "ustring.h"
 #include "operations.h"
+#include <math.h>
 
 namespace KJS {
@@ -122 +126 @@
 
 UChar::UChar(const UCharReference &c)
-#ifdef KJS_SWAPPED_CHAR
-  : lo(c.low()), hi(c.high())
-#else
-  : hi(c.high()), lo(c.low())
-#endif
+    : uc( c.unicode() )
 {
 }
@@ -132 +132 @@
 UChar UChar::toLower() const
 {
-  if (islower(lo) && hi == 0)
+  // ### properly supprot unicode tolower
+  if (uc >= 256 || islower(uc))
     return *this;
 
-  return UChar(0, tolower(lo));
+  return UChar(tolower(uc));
 }
 
 UChar UChar::toUpper() const
 {
-  if (isupper(lo) && hi == 0)
+  if (uc >= 256 || isupper(uc))
     return *this;
 
-  return UChar(0, toupper(lo));
+  return UChar(toupper(uc));
 }
 
@@ -237 +238 @@
 {
   char buf[40];
-  sprintf(buf, "%.16g", d);     // does the right thing
+
+  if (d == -0)
+    strcpy(buf,"0");
+  else if (KJS::isNaN(d))
+    strcpy(buf,"NaN");
+  else if (KJS::isPosInf(d))
+    strcpy(buf,"Infinity");
+  else if (KJS::isNegInf(d))
+    strcpy(buf,"-Infinity");
+  else
+    sprintf(buf, "%.16g", d);   // does the right thing
+
+  // ECMA 3rd ed. 9.8.1 9 e: "with no leading zeros"
+  int buflen = strlen(buf);
+  if (buflen >= 4 && buf[buflen-4] == 'e' && buf[buflen-2] == '0') {
+    buf[buflen-2] = buf[buflen-1];
+    buf[buflen-1] = 0;
+  }
+
   return UString(buf);
 }
@@ -265 +284 @@
   statBuffer = new char[size()+1];
   for(int i = 0; i < size(); i++)
-    statBuffer[i] = data()[i].lo;
+    statBuffer[i] = data()[i].low();
   statBuffer[size()] = '\0';
 
@@ -277 +296 @@
   UChar *d = new UChar[l];
   for (int i = 0; i < l; i++)
-    d[i].lo = c[i];
+    d[i].uc = c[i];
   rep = Rep::create(d, l);
 
@@ -287 +306 @@
   str.rep->ref();
   release();
-  rep = str.rep;  
+  rep = str.rep;
 
   return *this;
@@ -301 +320 @@
   const UChar *u = data();
   for(int i = 0; i < size(); i++, u++)
-    if (u->hi)
+    if (u->uc > 0xFF)
       return false;
 
@@ -321 +340 @@
 }
 
-double UString::toDouble() const
+double UString::toDouble( bool tolerant ) const
 {
   double d;
@@ -355 +374 @@
     char *end;
     d = strtod(c, &end);
-    if (d != 0.0 || end != c) {
+    if ((d != 0.0 || end != c) && d != HUGE_VAL && d != -HUGE_VAL) {
       c = end;
     } else {
@@ -376 +395 @@
   while (isspace(*c))
     c++;
-  if (*c != '\0')
+  // don't allow anything after - unless tolerant=true
+  if ( !tolerant && *c != '\0')
     d = NaN;
 
@@ -474 +494 @@
 }
 
-bool KJS::operator==(const UChar &c1, const UChar &c2)
-{
-  return ((c1.lo == c2.lo) & (c1.hi == c2.hi));
-}
-
 bool KJS::operator==(const UString& s1, const UString& s2)
 {
@@ -498 +513 @@
   const UChar *u = s1.data();
   while (*s2) {
-    if (u->lo != *s2 || u->hi != 0)
+    if (u->uc != *s2 )
       return false;
     s2++;
@@ -505 +520 @@
 
   return true;
-}
-
-bool KJS::operator==(const char *s1, const UString& s2)
-{
-  return operator==(s2, s1);
 }
 

trunk/JavaScriptCore/kjs/ustring.h

@@ +1 @@
+// -*- c-basic-offset: 2 -*-
 /*
  *  This file is part of the KDE libraries
@@ -17 +18 @@
  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  *  Boston, MA 02111-1307, USA.
+ *
+ *  $Id$
  */
 
-#ifndef _KJS_STRING_H_
-#define _KJS_STRING_H_
+#ifndef _KJS_USTRING_H_
+#define _KJS_USTRING_H_
 
 #ifdef HAVE_CONFIG_H
 #include <config.h>
+#endif
+
+#ifdef APPLE_CHANGES
+#include <KWQDef.h>
 #endif
 
@@ -36 +43 @@
 class QConstString;
 
-#if defined(__GNUC__)
-#define KJS_PACKED __attribute__((__packed__))
-#else
-#define KJS_PACKED
-#endif
-
 namespace KJS {
 
@@ -74 +75 @@
      * @return The higher byte of the character.
      */
-    unsigned char high() const { return hi; }
+    unsigned char high() const { return uc >> 8; }
     /**
      * @return The lower byte of the character.
      */
-    unsigned char low() const { return lo; }
+    unsigned char low() const { return uc & 0xFF; }
     /**
      * @return the 16 bit Unicode value of the character
      */
-    unsigned short unicode() const { return hi << 8 | lo; }
+    unsigned short unicode() const { return uc; }
   public:
     /**
@@ -102 +103 @@
     friend bool operator==(const UString& s1, const char *s2);
     friend bool operator<(const UString& s1, const UString& s2);
-#ifdef KJS_SWAPPED_CHAR
-    unsigned char lo;
-    unsigned char hi;
-#else
-    unsigned char hi;
-    unsigned char lo;
-#endif
-  } KJS_PACKED;
-
-
-#ifdef KJS_SWAPPED_CHAR // to avoid reorder warnings
-  inline UChar::UChar() : lo(0), hi(0) { }
-  inline UChar::UChar(unsigned char h , unsigned char l) : lo(l), hi(h) { }
-  inline UChar::UChar(unsigned short u) : lo(u & 0x00ff), hi(u >> 8) { }
-#else
-  inline UChar::UChar() : hi(0), lo(0) { }
-  inline UChar::UChar(unsigned char h , unsigned char l) : hi(h), lo(l) { }
-  inline UChar::UChar(unsigned short u) : hi(u >> 8), lo(u & 0x00ff) { }
-#endif
+
+    ushort uc;
+  };
+
+  inline UChar::UChar() : uc(0) { }
+  inline UChar::UChar(unsigned char h , unsigned char l) : uc(h << 8 | l) { }
+  inline UChar::UChar(unsigned short u) : uc(u) { }
 
   /**
@@ -155 +144 @@
      * @return Lower byte.
      */
-    unsigned char& low() const { return ref().lo; }
+    unsigned char low() const { return ref().uc & 0xFF; }
     /**
      * @return Higher byte.
      */
-    unsigned char& high() const { return ref().hi; }
+    unsigned char high() const { return ref().uc >> 8; }
     /**
      * @return Character converted to lower case.
@@ -365 +354 @@
      * indicated by a 0x or 0X prefix) and +/- Infinity.
      * Returns NaN if the conversion failed.
-     */
-    double toDouble() const;
+     * @param tolerant if true, toDouble can tolerate garbage after the number.
+     */
+    double toDouble(bool tolerant=false) const;
     /**
      * Attempts an conversion to an unsigned long integer. ok will be set
@@ -398 +388 @@
   };
 
-  bool operator==(const UChar &c1, const UChar &c2);
+  inline bool operator==(const UChar &c1, const UChar &c2) {
+    return (c1.uc == c2.uc);
+  }
   bool operator==(const UString& s1, const UString& s2);
   inline bool operator!=(const UString& s1, const UString& s2) {
@@ -408 +400 @@
     return !KJS::operator==(s1, s2);
   }
-  bool operator==(const char *s1, const UString& s2);
+  inline bool operator==(const char *s1, const UString& s2) {
+    return operator==(s2, s1);
+  }
   inline bool operator!=(const char *s1, const UString& s2) {
     return !KJS::operator==(s1, s2);