From 073151bba7b85ebf35866d9bb92d67025259d254 Mon Sep 17 00:00:00 2001
From: "rogerl%netscape.com"
 <rogerl%netscape.com@18797224-902f-48f8-a5cc-f745e15eee43>
Date: Tue, 8 Jan 2002 22:39:43 +0000
Subject: [PATCH] Fixed failure to parse 'prototype'. Added regexp support.

git-svn-id: svn://10.0.0.236/trunk@111599 18797224-902f-48f8-a5cc-f745e15eee43
---
 mozilla/js2/src/bytecodegen.cpp     |  215 +--
 mozilla/js2/src/bytecodegen.h       |   11 +-
 mozilla/js2/src/js2execution.cpp    |  125 +-
 mozilla/js2/src/js2runtime.cpp      |  282 +++-
 mozilla/js2/src/js2runtime.h        |   53 +-
 mozilla/js2/src/jsstring.cpp        |  177 ++-
 mozilla/js2/src/lexer.cpp           |    3 +
 mozilla/js2/src/property.h          |    4 +-
 mozilla/js2/src/regexp/regexp.c     | 1991 +++++++++++++++++++++++++++
 mozilla/js2/src/regexp/regexp.h     |  118 ++
 mozilla/js2/src/regexpwrapper.cpp   |   38 +
 mozilla/js2/src/winbuild/dikdik.dsp |  128 +-
 12 files changed, 2929 insertions(+), 216 deletions(-)
 create mode 100644 mozilla/js2/src/regexp/regexp.c
 create mode 100644 mozilla/js2/src/regexp/regexp.h
 create mode 100644 mozilla/js2/src/regexpwrapper.cpp

diff --git a/mozilla/js2/src/bytecodegen.cpp b/mozilla/js2/src/bytecodegen.cpp
index 106438af5ae..2073903c837 100644
--- a/mozilla/js2/src/bytecodegen.cpp
+++ b/mozilla/js2/src/bytecodegen.cpp
@@ -46,9 +46,6 @@
 
 #include <string.h>
 
-// this is the IdentifierList passed to the name lookup routines
-#define CURRENT_ATTR    mNamespaceList
-
 namespace JavaScript {    
 namespace JS2Runtime {
 
@@ -215,6 +212,10 @@ void SetterFunctionReference::emitCodeSequence(ByteCodeGen *bcg)
 
 void NameReference::emitCodeSequence(ByteCodeGen *bcg) 
 {
+    if (mNameSpace) {
+        bcg->addOp(UseOnceOp);
+        bcg->addStringRef(mNameSpace->mName);
+    }
     if (mAccess == Read)
         bcg->addOp(GetNameOp);
     else
@@ -224,6 +225,10 @@ void NameReference::emitCodeSequence(ByteCodeGen *bcg)
 
 void NameReference::emitTypeOf(ByteCodeGen *bcg)
 {
+    if (mNameSpace) {
+        bcg->addOp(UseOnceOp);
+        bcg->addStringRef(mNameSpace->mName);
+    }
     bcg->addOp(GetTypeOfNameOp);
     bcg->addStringRef(mName); 
     bcg->addOp(TypeOfOp);
@@ -231,6 +236,10 @@ void NameReference::emitTypeOf(ByteCodeGen *bcg)
 
 void NameReference::emitDelete(ByteCodeGen *bcg)
 {
+    if (mNameSpace) {
+        bcg->addOp(UseOnceOp);
+        bcg->addStringRef(mNameSpace->mName);
+    }
     bcg->addOp(DeleteNameOp);
     bcg->addStringRef(mName); 
 }
@@ -286,6 +295,7 @@ ByteCodeData gByteCodeData[OpCodeCount] = {
 { 1,        "LoadConstantZero", },
 { 1,        "LoadConstantNumber", },
 { 1,        "LoadConstantString", },
+{ 1,        "LoadConstantRegExp", },
 { 1,        "LoadThis", },
 { 1,        "LoadFunction", },
 { 1,        "LoadType", },
@@ -354,9 +364,10 @@ ByteCodeData gByteCodeData[OpCodeCount] = {
 { 1,        "LoadGlobalObject", },
 { 0,        "PushScope", },
 { 0,        "PopScope", },
-{ 0,        "NewClosure" },
-{ -1,       "Juxtapose" },
-{ -1,       "NamedArgument" },
+{ 0,        "NewClosure", },
+{ -1,       "Juxtapose", },
+{ -1,       "NamedArgument", },
+{ -1,       "Use", },
 
 };
 
@@ -373,18 +384,28 @@ ByteCodeModule::ByteCodeModule(ByteCodeGen *bcg, JSFunction *f)
 
     mLocalsCount = bcg->mScopeChain->countVars();
     mStackDepth = toUInt32(bcg->mStackMax);
+
+    mErrorPos = 0;
+}
+
+ByteCodeModule::ByteCodeModule(size_t pos)
+{
+    mCodeBase = NULL;
+    mCodeMap = NULL;
+    mCodeMapLength = 0;
+    mErrorPos = pos;
 }
 
 ByteCodeModule::~ByteCodeModule()
 {
-    delete[] mCodeBase;
-    delete[] mCodeMap;
+    if (mCodeBase) delete[] mCodeBase;
+    if (mCodeMap) delete[] mCodeMap;
 }
 
 size_t ByteCodeModule::getPositionForPC(uint32 pc)
 {
     if (mCodeMapLength == 0)
-        return 0;
+        return mErrorPos;
 
     for (uint32 i = 0; i < (mCodeMapLength - 1); i++) {
         uint32 pos1 = mCodeMap[i].first;
@@ -849,6 +870,7 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
             uint32 labelAtTestCondition = getLabel(); 
             uint32 labelAtEnd = getLabel(); 
 /*
+            if (object == null) goto end;
             iterator = object.forin()
             goto test
             top:
@@ -874,10 +896,16 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
 
 
                 genExpr(f->expr2);
+                addOp(DupOp);
+                addOp(LoadConstantNullOp);
+                addOp(DoOperatorOp);
+                addByte(Equal);
+                addOp(JumpTrueOp);
+                addFixup(labelAtEnd);
+
                 objectWriteRef->emitCodeSequence(this);
                 addOp(GetInvokePropertyOp);
-//              addIdentifierRef(widenCString("Iterator"), widenCString("forin"));
-                addStringRef(m_cx->Forin_StringAtom);
+                addStringRef(m_cx->Forin_StringAtom);   // XXX supposed to be in Iterator namespace
                 addOpAdjustDepth(InvokeOp, -1);
                 addLong(0);
                 addByte(Explicit);
@@ -893,7 +921,7 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
                 if (f->initializer->getKind() == StmtNode::Var) {
                     VariableStmtNode *vs = checked_cast<VariableStmtNode *>(f->initializer);
                     VariableBinding *v = vs->bindings;
-                    value = mScopeChain->getName(*v->name, CURRENT_ATTR, Write);
+                    value = mScopeChain->getName(*v->name, NULL, Write);
                 }
                 else {
                     if (f->initializer->getKind() == StmtNode::expression) {
@@ -920,7 +948,7 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
             setLabel(labelAtIncrement);
                 objectReadRef->emitCodeSequence(this);
                 addOp(GetInvokePropertyOp);
-                addStringRef(m_cx->Next_StringAtom);
+                addStringRef(m_cx->Next_StringAtom);   // XXX supposed to be in Iterator namespace
                 iteratorReadRef->emitCodeSequence(this);
                 addOpAdjustDepth(InvokeOp, -2);
                 addLong(1);
@@ -941,7 +969,7 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
             setLabel(breakLabel);
                 objectReadRef->emitCodeSequence(this);
                 addOp(GetInvokePropertyOp);
-                addStringRef(m_cx->Done_StringAtom);
+                addStringRef(m_cx->Done_StringAtom);   // XXX supposed to be in Iterator namespace
                 iteratorReadRef->emitCodeSequence(this);
                 addOpAdjustDepth(InvokeOp, -2);
                 addLong(1);
@@ -1232,17 +1260,30 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
                 throw exception             | 
                                             |
             catchLabel:                  <---
+
+                    the incoming exception is on the top of the stack at this point
+
                 catch (exception) { // catch handler label popped off
                         // any throw from in here must jump to the finallyInvoker
                         // (i.e. not the catch handler!)
-                    the incoming exception
-                    is on the top of the stack. it
-                    get stored into the variable
-                    we've associated with the catch clause
+
+                    Of the many catch clauses specified, only the one whose exception variable type
+                    matches the type of the incoming exception is executed...
+
+                    dup
+                    push type of exception-variable
+                    is
+                    jumpfalse-->next catch
+                    
+                    setlocalvar exception-variable
+                    pop
+                    <catch body>
+
 
                 }
                 // 'normal' fall thru from catch
                 jsr finally
+                jump finished
 
             finished:
 */
@@ -1303,26 +1344,35 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
                 ASSERT(mStackTop == 0);
                 mStackTop = 1;
                 if (mStackMax < 1) mStackMax = 1;
-                while (c) {
-                    Reference *ref = mScopeChain->getName(c->name, CURRENT_ATTR, Write);
+                uint32 nextCatch = NotALabel;
+                while (c) {                    
+                    if (c->next && c->type) {
+                        nextCatch = getLabel();
+                        addOp(DupOp);
+                        genCodeForExpression(c->type);
+                        addOp(IsOp);
+                        addOp(JumpFalseOp);
+                        addFixup(nextCatch);
+                    }
+                    Reference *ref = mScopeChain->getName(c->name, NULL, Write);
                     ref->emitImplicitLoad(this);
                     ref->emitCodeSequence(this);
                     delete ref;
+                    addOp(PopOp);
                     genCodeForStatement(c->stmt, static_cg, t_finallyLabel);
+                    if (t->finally) {
+                        addOp(JsrOp);
+                        addFixup(t_finallyLabel);
+                    }
                     c = c->next;
                     if (c) {
+						addOp(JumpOp);
+						addFixup(finishedLabel);
                         mStackTop = 1;
-                        Reference *ref = mScopeChain->getName(c->name, CURRENT_ATTR, Read);
-                        ref->emitCodeSequence(this);
-                        delete ref;
+                        if (nextCatch != NotABanana)
+                            setLabel(nextCatch);
                     }
                 }
-                addOp(PopOp);       // the exception object has persisted 
-                                    // on the top of the stack until here
-                if (t->finally) {
-                    addOp(JsrOp);
-                    addFixup(t_finallyLabel);
-                }
             }
             setLabel(finishedLabel);
         }
@@ -1332,15 +1382,8 @@ bool ByteCodeGen::genCodeForStatement(StmtNode *p, ByteCodeGen *static_cg, uint3
             UseStmtNode *u = checked_cast<UseStmtNode *>(p);
             ExprList *eList = u->namespaces;
             while (eList) {
-                ExprNode *e = eList->expr;
-                if (e->getKind() == ExprNode::identifier) {
-                    NOT_REACHED("implement me");
-                    // ***** What is this supposed to do?  id is not used anywhere.
-                    // AttributeList *id = new(m_cx->mArena) AttributeList(e);
-                    // id->next = CURRENT_ATTR;
-                }
-                else
-                    NOT_REACHED("implement me");
+                genExpr(eList->expr);
+                addOp(UseOp);
                 eList = eList->next;
             }
 
@@ -1382,12 +1425,25 @@ Reference *ByteCodeGen::genReference(ExprNode *p, Access acc)
     case ExprNode::identifier:
         {
             const StringAtom &name = checked_cast<IdentifierExprNode *>(p)->name;
-            Reference *ref = mScopeChain->getName(name, CURRENT_ATTR, acc);            
+            Reference *ref = mScopeChain->getName(name, NULL, acc);            
             if (ref == NULL)
-                ref = new NameReference(name, acc);
+                ref = new NameReference(name, NULL, acc);
             ref->emitImplicitLoad(this);
             return ref;
         }
+    case ExprNode::qualify:
+        {
+            QualifyExprNode *qe = checked_cast<QualifyExprNode *>(p);
+            const StringAtom &name = checked_cast<IdentifierExprNode *>(p)->name;
+            const StringAtom &qualifierName = checked_cast<IdentifierExprNode *>(qe->qualifier)->name;
+
+            NamespaceList *ns = new NamespaceList(qualifierName, NULL);
+            Reference *ref = mScopeChain->getName(name, ns, acc);            
+            if (ref == NULL)
+                ref = new NameReference(name, ns, acc);
+
+            return ref;
+        }
     case ExprNode::dot:
         {
             BinaryExprNode *b = checked_cast<BinaryExprNode *>(p);
@@ -1421,24 +1477,19 @@ Reference *ByteCodeGen::genReference(ExprNode *p, Access acc)
                 const StringAtom &fieldName = checked_cast<IdentifierExprNode *>(b->op2)->name;
                 const StringAtom &qualifierName = checked_cast<IdentifierExprNode *>(qe->qualifier)->name;
 
-                NamespaceList *oldNS = mNamespaceList;
-                mNamespaceList = new NamespaceList(&qualifierName, mNamespaceList);
-
-                Reference *ref = lType->genReference(true, fieldName, mNamespaceList, acc, Property::NoAttribute);
+                NamespaceList *ns = new NamespaceList(qualifierName, NULL);
+                Reference *ref = lType->genReference(true, fieldName, ns, acc, Property::NoAttribute);
                 if (ref == NULL)
-                    ref = new PropertyReference(fieldName, acc, Object_Type, 0);
-
-                delete mNamespaceList;
-                mNamespaceList = oldNS;
+                    ref = new PropertyReference(fieldName, ns, acc, Object_Type, 0);
 
                 return ref;
             }
             else {
                 ASSERT(b->op2->getKind() == ExprNode::identifier);
                 const StringAtom &fieldName = checked_cast<IdentifierExprNode *>(b->op2)->name;
-                Reference *ref = lType->genReference(true, fieldName, CURRENT_ATTR, acc, 0);
+                Reference *ref = lType->genReference(true, fieldName, NULL, acc, 0);
                 if (ref == NULL)
-                    ref = new PropertyReference(fieldName, acc, Object_Type, Property::NoAttribute);
+                    ref = new PropertyReference(fieldName, NULL, acc, Object_Type, Property::NoAttribute);
                 return ref;
             }
 
@@ -1457,12 +1508,12 @@ void ByteCodeGen::genReferencePair(ExprNode *p, Reference *&readRef, Reference *
     case ExprNode::identifier:
         {
             const StringAtom &name = checked_cast<IdentifierExprNode *>(p)->name;
-            readRef = mScopeChain->getName(name, CURRENT_ATTR, Read);            
+            readRef = mScopeChain->getName(name, NULL, Read);            
             if (readRef == NULL)
-                readRef = new NameReference(name, Read);
-            writeRef = mScopeChain->getName(name, CURRENT_ATTR, Write);            
+                readRef = new NameReference(name, NULL, Read);
+            writeRef = mScopeChain->getName(name, NULL, Write);            
             if (writeRef == NULL)
-                writeRef = new NameReference(name, Write);
+                writeRef = new NameReference(name, NULL, Write);
             readRef->emitImplicitLoad(this);
         }
         break;
@@ -1503,12 +1554,12 @@ void ByteCodeGen::genReferencePair(ExprNode *p, Reference *&readRef, Reference *
             }
             else {
                 const StringAtom &fieldName = checked_cast<IdentifierExprNode *>(b->op2)->name;
-                readRef = lType->genReference(true, fieldName, CURRENT_ATTR, Read, 0);
+                readRef = lType->genReference(true, fieldName, NULL, Read, 0);
                 if (readRef == NULL)
-                    readRef = new PropertyReference(fieldName, Read, Object_Type, Property::NoAttribute);
-                writeRef = lType->genReference(true, fieldName, CURRENT_ATTR, Write, 0);
+                    readRef = new PropertyReference(fieldName, NULL, Read, Object_Type, Property::NoAttribute);
+                writeRef = lType->genReference(true, fieldName, NULL, Write, 0);
                 if (writeRef == NULL)
-                    writeRef = new PropertyReference(fieldName, Write, Object_Type, Property::NoAttribute);
+                    writeRef = new PropertyReference(fieldName, NULL, Write, Object_Type, Property::NoAttribute);
             }
         }
         break;
@@ -2266,31 +2317,7 @@ BinaryOpEquals:
         {
             FunctionExprNode *f = checked_cast<FunctionExprNode *>(p);
             JSFunction *fnc = new JSFunction(m_cx, NULL, mScopeChain);
-
-            uint32 reqArgCount = 0;
-            uint32 optArgCount = 0;
-            uint32 namedArgCount = 0;
-/*
-            VariableBinding *b = f->function.parameters;
-            while (b != f->function.optParameters) {
-                reqArgCount++;
-                b = b->next;
-            }
-            while (b != f->function.restParameter) {
-                optArgCount++;
-                b = b->next;
-            }
-            b = f->function.namedParameters;
-            while (b) {
-                namedArgCount++;
-                b = b->next;
-            }
-            fnc->setArgCounts(m_cx, reqArgCount, optArgCount, namedArgCount,
-                              f->function.restParameter != f->function.namedParameters, f->function.restIsNamed);
-*/
             fnc->countParameters(m_cx, f->function);
-
-
 	    if (mScopeChain->isPossibleUncheckedFunction(f->function))
 		fnc->setIsPrototype(true);
 
@@ -2362,7 +2389,22 @@ BinaryOpEquals:
         }
         break;
     case ExprNode::regExp:
-        m_cx->reportError(Exception::internalError, "Regular expressions nyi", p->pos);
+        {
+            RegExpExprNode *v = checked_cast<RegExpExprNode *>(p);
+            JSValue reValue = kNullValue;
+            JSValue args[2];
+            args[0] = JSValue(&v->re);
+            args[1] = JSValue(&v->flags);
+            ByteCodeModule *curModule = m_cx->mCurModule;
+            ByteCodeModule errorHandlingModule(p->pos);
+            m_cx->mCurModule = &errorHandlingModule;
+            reValue = RegExp_Constructor(m_cx, reValue, args, 2);
+            m_cx->mCurModule = curModule;
+            ASSERT(reValue.isObject());
+            addOp(LoadConstantRegExpOp);
+            addPointer(reValue.object);
+            return RegExp_Type;
+        }
         break;
     default:
         NOT_REACHED("Not Implemented Yet");
@@ -2474,6 +2516,8 @@ uint32 printInstruction(Formatter &f, uint32 i, const ByteCodeModule& bcm)
         i += 4;
         break;
 
+    case UseOp:
+    case UseOnceOp:
     case GetNameOp:
     case GetTypeOfNameOp:
     case SetNameOp:
@@ -2487,6 +2531,11 @@ uint32 printInstruction(Formatter &f, uint32 i, const ByteCodeModule& bcm)
         i += 4;
         break;
 
+    case LoadConstantRegExpOp:
+        printFormat(f, "0x%X", bcm.getLong(i));
+        i += 4;
+        break;
+
     case LoadConstantNumberOp:
         f << bcm.getNumber(&bcm.mCodeBase[i]);
         i += 8;
diff --git a/mozilla/js2/src/bytecodegen.h b/mozilla/js2/src/bytecodegen.h
index 8d5e6f06da4..419989d0745 100644
--- a/mozilla/js2/src/bytecodegen.h
+++ b/mozilla/js2/src/bytecodegen.h
@@ -76,6 +76,7 @@ typedef enum {
     LoadConstantZeroOp,     //                          --> <+0.0 value object>
     LoadConstantNumberOp,   // <poolindex>              --> <Number value object>
     LoadConstantStringOp,   // <poolindex>              --> <String value object>
+    LoadConstantRegExpOp,   // <poolindex>              --> <RegExp value object>
     LoadThisOp,             //                          --> <this object>      
     LoadFunctionOp,         // <pointer>        XXX !!! XXX
     LoadTypeOp,             // <pointer>        XXX !!! XXX
@@ -155,6 +156,8 @@ typedef enum {
     NewClosureOp,           //                          <function> --> <function>
     JuxtaposeOp,            //                          <attribute> <attribute> --> <attribute>
     NamedArgOp,             //                          <object> <string> --> <named arg object>
+    UseOp,                  //                          <object> -->
+    UseOnceOp,              //                          <object> -->
 
     OpCodeCount
 
@@ -173,6 +176,7 @@ extern ByteCodeData gByteCodeData[OpCodeCount];
     public:
             
         ByteCodeModule(ByteCodeGen *bcg, JSFunction *f);
+        ByteCodeModule(size_t pos);
         ~ByteCodeModule();
 
 #ifdef DEBUG
@@ -183,7 +187,7 @@ extern ByteCodeData gByteCodeData[OpCodeCount];
         uint32 getLong(uint32 index) const          { return *((uint32 *)&mCodeBase[index]); }
         uint16 getShort(uint32 index) const         { return *((uint16 *)&mCodeBase[index]); }
         int32 getOffset(uint32 index) const         { return *((int32 *)&mCodeBase[index]); }
-        const String *getString(uint32 index) const { return (const String *)(index); }
+        const StringAtom *getString(uint32 index) const { return (const StringAtom *)(index); }
         float64 getNumber(uint8 *p) const       { return *((float64 *)p); }
 
         void setSource(const String &source, const String &sourceLocation)
@@ -205,8 +209,10 @@ extern ByteCodeData gByteCodeData[OpCodeCount];
 
         PC_Position *mCodeMap;
         uint32 mCodeMapLength;
+        size_t mErrorPos;
 
         size_t getPositionForPC(uint32 pc);
+
             
     };
     Formatter& operator<<(Formatter& f, const ByteCodeModule& bcm);
@@ -254,7 +260,6 @@ extern ByteCodeData gByteCodeData[OpCodeCount];
                 mScopeChain(scopeChain), 
                 mPC_Map(new CodeMap),
                 m_cx(cx), 
-                mNamespaceList(NULL) ,
                 mStackTop(0),
                 mStackMax(0)
         { }
@@ -297,8 +302,6 @@ extern ByteCodeData gByteCodeData[OpCodeCount];
         std::vector<Label> mLabelList;
         std::vector<uint32> mLabelStack;
 
-        NamespaceList *mNamespaceList;
-
         int32 mStackTop;        // keep these as signed so as to
         int32 mStackMax;        // track if they go negative.
 
diff --git a/mozilla/js2/src/js2execution.cpp b/mozilla/js2/src/js2execution.cpp
index 39bb66c31a0..55d460e8c66 100644
--- a/mozilla/js2/src/js2execution.cpp
+++ b/mozilla/js2/src/js2execution.cpp
@@ -56,8 +56,6 @@
 
 #include "fdlibm_ns.h"
 
-// this is the AttributeList passed to the name lookup routines
-#define CURRENT_ATTR    (NULL)
 
 namespace JavaScript {    
 namespace JS2Runtime {
@@ -68,6 +66,7 @@ inline char narrow(char16 ch) { return char(ch); }
 JSValue Context::readEvalString(const String &str, const String& fileName, ScopeChain *scopeChain, const JSValue& thisValue)
 {
     JSValue result = kUndefinedValue;
+    NamespaceList *useOnceNamespace = NULL;
 
     Arena a;
     Parser p(mWorld, a, mFlags, str, fileName);
@@ -165,7 +164,7 @@ bool Context::executeOperator(Operator op, JSType *t1, JSType *t2)
     }
     else {
         mActivationStack.push(new Activation(mLocals, mStack, mStackTop - 2, mScopeChain,
-                                                mArgumentBase, mThis, mPC, mCurModule));
+                                                mArgumentBase, mThis, mPC, mCurModule, mNamespaceList));
         mThis = newThis;
         mCurModule = target->getByteCode();
         mArgumentBase = getBase(stackSize() - 2);
@@ -189,7 +188,7 @@ JSValue Context::invokeFunction(JSFunction *target, const JSValue& thisValue, JS
 JSValue Context::interpret(JS2Runtime::ByteCodeModule *bcm, int offset, ScopeChain *scopeChain, const JSValue& thisValue, JSValue *argv, uint32 /*argc*/)
 { 
     Activation *prev = new Activation(mLocals, mStack, mStackTop, mScopeChain,
-                                            mArgumentBase, mThis, NULL, mCurModule); // use NULL pc value to force interpret loop to exit
+                                            mArgumentBase, mThis, NULL, mCurModule, mNamespaceList); // use NULL pc value to force interpret loop to exit
     uint32 activationHeight = mActivationStack.size();
     mActivationStack.push(prev);   
     mThis = thisValue;
@@ -234,6 +233,7 @@ JSValue Context::interpret(JS2Runtime::ByteCodeModule *bcm, int offset, ScopeCha
         if (scopeChain == NULL)
             delete mScopeChain;
 
+        mNamespaceList = prev->mNamespaceList;
         mCurModule = prev->mModule;
         mStack = prev->mStack;
         mStackTop = 0;      // we're processing an exception, no need to preserve the stack
@@ -262,6 +262,7 @@ JSValue Context::interpret(JS2Runtime::ByteCodeModule *bcm, int offset, ScopeCha
     if (scopeChain == NULL)
         delete mScopeChain;
 
+    mNamespaceList = prev->mNamespaceList;
     mCurModule = prev->mModule;
     mStack = prev->mStack;
     mStackTop = prev->mStackTop;
@@ -430,6 +431,7 @@ JSValue *Context::buildArgumentBlock(JSFunction *target, uint32 &argCount)
 
 JSValue Context::interpret(uint8 *pc, uint8 *endPC)
 {
+    bool useOnceNamespace = false;
     JSValue result = kUndefinedValue;
     while (pc != endPC) {
         mPC = pc;
@@ -674,7 +676,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         mActivationStack.push(new Activation(mLocals, mStack, mStackTop - (cleanUp + 1),
                                                                     mScopeChain,
                                                                     mArgumentBase, oldThis,
-                                                                    pc, mCurModule));
+                                                                    pc, mCurModule, mNamespaceList));
                         mScopeChain = target->getScopeChain();
                         mScopeChain->addScope(target->getParameterBarrel());
                         mScopeChain->addScope(target->getActivation());
@@ -702,7 +704,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         mActivationStack.push(new Activation(mLocals, mStack, mStackTop - (cleanUp + 1),
                                                                     mScopeChain,
                                                                     mArgumentBase, oldThis,
-                                                                    pc, mCurModule));
+                                                                    pc, mCurModule, mNamespaceList));
                         JSValue result = (target->getNativeCode())(this, mThis, argBase, argCount);
                         Activation *prev = mActivationStack.top();
                         delete prev;
@@ -732,6 +734,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     mScopeChain->popScope();
                     mScopeChain->popScope();
 
+                    mNamespaceList = prev->mNamespaceList;
                     mCurModule = prev->mModule;
                     pc = prev->mPC;
                     endPC = mCurModule->mCodeBase + mCurModule->mLength;
@@ -762,6 +765,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     mScopeChain->popScope();
                     mScopeChain->popScope();
 
+                    mNamespaceList = prev->mNamespaceList;
                     mCurModule = prev->mModule;
                     pc = prev->mPC;
                     endPC = mCurModule->mCodeBase + mCurModule->mLength;
@@ -818,12 +822,19 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
             case LoadConstantZeroOp:
                 pushValue(kPositiveZero);
                 break;
+            case LoadConstantRegExpOp:
+                {
+                    JSObject *t = *((JSObject **)pc);
+                    pc += sizeof(JSObject *);
+                    pushValue(JSValue(t));
+                }
+                break;
             case DeleteNameOp:
                 {
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
-                    const String &name = *mCurModule->getString(index);
-                    if (mScopeChain->deleteName(this, name, CURRENT_ATTR))
+                    const StringAtom &name = *mCurModule->getString(index);
+                    if (mScopeChain->deleteName(this, name, mNamespaceList))
                         pushValue(kTrueValue);
                     else
                         pushValue(kFalseValue);
@@ -839,10 +850,10 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         obj = base.object;
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
-                    const String &name = *mCurModule->getString(index);
+                    const StringAtom &name = *mCurModule->getString(index);
                     PropertyIterator it;
-                    if (obj->hasOwnProperty(name, CURRENT_ATTR, Read, &it))
-                        if (obj->deleteProperty(name, CURRENT_ATTR))
+                    if (obj->hasOwnProperty(name, mNamespaceList, Read, &it))
+                        if (obj->deleteProperty(name, mNamespaceList))
                             pushValue(kTrueValue);
                         else
                             pushValue(kFalseValue);
@@ -930,7 +941,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         JSFunction *obj = t.function;                        
                         PropertyIterator i;
                         JSFunction *target = NULL;
-                        if (obj->hasProperty(HasInstance_StringAtom, CURRENT_ATTR, Read, &i)) {
+                        if (obj->hasProperty(HasInstance_StringAtom, mNamespaceList, Read, &i)) {
                             JSValue hi = obj->getPropertyValue(i);
                             if (hi.isFunction())
                                 target = hi.function;
@@ -958,10 +969,10 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                 {
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
-                    const String &name = *mCurModule->getString(index);
-                    JSObject *parent = mScopeChain->getNameValue(this, name, CURRENT_ATTR);
+                    const StringAtom &name = *mCurModule->getString(index);
+                    JSObject *parent = mScopeChain->getNameValue(this, name, mNamespaceList);
                     JSValue result = topValue();
-                    if (result.isFunction()) {
+                    if (result.isFunction() && !result.function->hasBoundThis()) {
                         popValue();
                         if (result.function->isConstructor())
                             // A constructor has to be called with a NULL 'this' in order to prompt it
@@ -970,31 +981,49 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         else
                             pushValue(JSValue((JSFunction *)(new JSBoundFunction(result.function, parent))));
                     }
+                    if (useOnceNamespace) {
+                        NamespaceList *t = mNamespaceList->mNext;
+                        delete mNamespaceList;
+                        useOnceNamespace = false;
+                        mNamespaceList = t;
+                    }                        
                 }
                 break;
             case SetNameOp:
                 {
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
-                    const String &name = *mCurModule->getString(index);
+                    const StringAtom &name = *mCurModule->getString(index);
                     JSValue v = topValue();
                     if (v.isFunction() && v.function->hasBoundThis() && !v.function->isMethod()) {
                         popValue();
                         pushValue(JSValue(v.function->getFunction()));
                     }
-                    mScopeChain->setNameValue(this, name, CURRENT_ATTR);
+                    mScopeChain->setNameValue(this, name, mNamespaceList);
+                    if (useOnceNamespace) {
+                        NamespaceList *t = mNamespaceList->mNext;
+                        delete mNamespaceList;
+                        useOnceNamespace = false;
+                        mNamespaceList = t;
+                    }                        
                 }
                 break;
             case GetTypeOfNameOp:
                 {
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
-                    const String &name = *mCurModule->getString(index);
-                    if (mScopeChain->hasNameValue(name, CURRENT_ATTR)) {
-                        mScopeChain->getNameValue(this, name, CURRENT_ATTR);
+                    const StringAtom &name = *mCurModule->getString(index);
+                    if (mScopeChain->hasNameValue(name, mNamespaceList)) {
+                        mScopeChain->getNameValue(this, name, mNamespaceList);
                     }
                     else
                         pushValue(kUndefinedValue);
+                    if (useOnceNamespace) {
+                        NamespaceList *t = mNamespaceList->mNext;
+                        delete mNamespaceList;
+                        useOnceNamespace = false;
+                        mNamespaceList = t;
+                    }                        
                 }
                 break;
             case GetElementOp:
@@ -1050,7 +1079,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         JSValue index = popValue();
                         popValue();     // discard base
                         const String *name = index.toString(this).string;
-                        obj->getProperty(this, *name, CURRENT_ATTR);
+                        obj->getProperty(this, *name, mNamespaceList);
                     }
                     // if the result is a method of some kind, bind
                     // the base object to it
@@ -1122,7 +1151,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         JSValue index = popValue();
                         popValue();     // discard base
                         const String *name = index.toString(this).string;
-                        obj->setProperty(this, *name, CURRENT_ATTR, v);
+                        obj->setProperty(this, *name, mNamespaceList, v);
                         pushValue(v);                
                     }
                 }
@@ -1174,8 +1203,8 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                         popValue();     // discard base
                         const String *name = index.toString(this).string;
                         PropertyIterator it;
-                        if (obj->hasOwnProperty(*name, CURRENT_ATTR, Read, &it))
-                            obj->deleteProperty(*name, CURRENT_ATTR);
+                        if (obj->hasOwnProperty(*name, mNamespaceList, Read, &it))
+                            obj->deleteProperty(*name, mNamespaceList);
                         pushValue(kTrueValue);
                     }
                 }
@@ -1191,8 +1220,8 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
                     mPC = pc;
-                    const String &name = *mCurModule->getString(index);
-                    obj->getProperty(this, name, CURRENT_ATTR);
+                    const StringAtom &name = *mCurModule->getString(index);
+                    obj->getProperty(this, name, mNamespaceList);
                     // if the result is a method of some kind, bind
                     // the base object to it
                     JSValue result = topValue();
@@ -1223,13 +1252,8 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     pc += sizeof(uint32);
                     mPC = pc;
                     
-                    const String &name = *mCurModule->getString(index);
-
-//                    const String &name = *mCurModule->getIdentifierString(index);
-//                    AttributeList *attr = mCurModule->getIdentifierAttr(index);
-//                    attr->next = CURRENT_ATTR;
-
-                    obj->getProperty(this, name, CURRENT_ATTR);
+                    const StringAtom &name = *mCurModule->getString(index);
+                    obj->getProperty(this, name, mNamespaceList);
                 }
                 break;
             case SetPropertyOp:
@@ -1247,8 +1271,8 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     uint32 index = *((uint32 *)pc);
                     pc += sizeof(uint32);
                     mPC = pc;
-                    const String &name = *mCurModule->getString(index);
-                    obj->setProperty(this, name, CURRENT_ATTR, v);
+                    const StringAtom &name = *mCurModule->getString(index);
+                    obj->setProperty(this, name, mNamespaceList, v);
                     pushValue(v);
                 }
                 break;
@@ -1269,7 +1293,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                             mActivationStack.push(new Activation(mLocals, mStack, mStackTop - 1, 
                                                                     mScopeChain,
                                                                     mArgumentBase, mThis,
-                                                                    pc, mCurModule));
+                                                                    pc, mCurModule, mNamespaceList));
                             mThis = newThis;
                             mCurModule = target->getByteCode();
                             pc = mCurModule->mCodeBase;
@@ -1359,7 +1383,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                             target = typeValue->function;
                             newThis = Object_Type->newInstance(this);
                             PropertyIterator i;
-                            if (target->hasProperty(Prototype_StringAtom, CURRENT_ATTR, Read, &i)) {
+                            if (target->hasProperty(Prototype_StringAtom, mNamespaceList, Read, &i)) {
                                 JSValue v = target->getPropertyValue(i);
                                 newThis.object->mPrototype = v.toObject(this).object;
                             }
@@ -1660,6 +1684,24 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     pushValue(mapValueToType(v, toType));
                 }
                 break;
+            case UseOnceOp:
+                {
+                    uint32 index = *((uint32 *)pc);
+                    pc += sizeof(uint32);
+                    const StringAtom &nameSpace = *mCurModule->getString(index);
+                    ASSERT(useOnceNamespace == false);
+                    useOnceNamespace = true;
+                    mNamespaceList = new NamespaceList(nameSpace, mNamespaceList);
+                }
+                break;
+            case UseOp:
+                {
+                    uint32 index = *((uint32 *)pc);
+                    pc += sizeof(uint32);
+                    const StringAtom &nameSpace = *mCurModule->getString(index);
+                    mNamespaceList = new NamespaceList(nameSpace, mNamespaceList);
+                }
+                break;
 
             default:
                 reportError(Exception::internalError, "Bad Opcode");
@@ -1686,6 +1728,7 @@ JSValue Context::interpret(uint8 *pc, uint8 *endPC)
                     } while (hndlr->mActivation != curAct);
                     if (jsx.hasKind(Exception::userException))  // snatch the exception before the stack gets clobbered
                         x = popValue();
+                    mNamespaceList = prev->mNamespaceList;
                     mCurModule = prev->mModule;
                     endPC = mCurModule->mCodeBase + mCurModule->mLength;
                     mLocals = prev->mLocals;
@@ -2352,13 +2395,13 @@ JSValue JSValue::valueToString(Context *cx, const JSValue& value)
     if (obj) {
         JSFunction *target = NULL;
         PropertyIterator i;
-        if (obj->hasProperty(cx->ToString_StringAtom, CURRENT_ATTR, Read, &i)) {
+        if (obj->hasProperty(cx->ToString_StringAtom, NULL, Read, &i)) {
             JSValue v = obj->getPropertyValue(i);
             if (v.isFunction())
                 target = v.function;
         }
         if (target == NULL) {
-            if (obj->hasProperty(cx->ValueOf_StringAtom, CURRENT_ATTR, Read, &i)) {
+            if (obj->hasProperty(cx->ValueOf_StringAtom, NULL, Read, &i)) {
                 JSValue v = obj->getPropertyValue(i);
                 if (v.isFunction())
                     target = v.function;
@@ -2414,7 +2457,7 @@ JSValue JSValue::toPrimitive(Context *cx, Hint hint) const
     }
 
 
-    if (obj->hasProperty(*first, CURRENT_ATTR, Read, &i)) {
+    if (obj->hasProperty(*first, NULL, Read, &i)) {
         JSValue v = obj->getPropertyValue(i);
         if (v.isFunction()) {
             target = v.function;
@@ -2425,7 +2468,7 @@ JSValue JSValue::toPrimitive(Context *cx, Hint hint) const
             }
         }
     }
-    if (obj->hasProperty(*second, CURRENT_ATTR, Read, &i)) {
+    if (obj->hasProperty(*second, NULL, Read, &i)) {
         JSValue v = obj->getPropertyValue(i);
         if (v.isFunction()) {
             target = v.function;
diff --git a/mozilla/js2/src/js2runtime.cpp b/mozilla/js2/src/js2runtime.cpp
index d6401c2abe7..e5201b73deb 100644
--- a/mozilla/js2/src/js2runtime.cpp
+++ b/mozilla/js2/src/js2runtime.cpp
@@ -56,6 +56,8 @@
 
 #include "fdlibm_ns.h"
 
+#include "regexp.h"
+
 // this is the AttributeList passed to the name lookup routines
 #define CURRENT_ATTR    (NULL)
 
@@ -81,6 +83,7 @@ JSType *Attribute_Type;
 JSType *NamedArgument_Type;
 JSArrayType *Array_Type;
 JSType *Date_Type;
+JSType *RegExp_Type;
 JSType *Error_Type;
 JSType *EvalError_Type;
 JSType *RangeError_Type;
@@ -247,8 +250,8 @@ void JSObject::defineTempVariable(Context *cx, Reference *&readRef, Reference *&
     sprintf(buf, "%%tempvar%%_%d", tempVarCount++);
     const String &name = cx->mWorld.identifiers[buf];
     /* Property *prop = */defineVariable(cx, name, (NamespaceList *)NULL, Property::NoAttribute, type);
-    readRef = new NameReference(name, Read, Object_Type, 0);
-    writeRef = new NameReference(name, Write, Object_Type, 0);
+    readRef = new NameReference(name, NULL, Read, Object_Type, 0);
+    writeRef = new NameReference(name, NULL, Write, Object_Type, 0);
 }
 
 
@@ -342,9 +345,9 @@ Reference *JSObject::genReference(bool hasBase, const String& name, NamespaceLis
         switch (prop->mFlag) {
         case ValuePointer:
             if (hasBase)
-                return new PropertyReference(name, acc, prop->mType, prop->mAttributes);
+                return new PropertyReference(name, names, acc, prop->mType, prop->mAttributes);
             else
-                return new NameReference(name, acc, prop->mType, prop->mAttributes);
+                return new NameReference(name, names, acc, prop->mType, prop->mAttributes);
         case FunctionPair:
             if (acc == Read)
                 return new GetterFunctionReference(prop->mData.fPair.getterF, prop->mAttributes);
@@ -542,7 +545,7 @@ void JSArrayInstance::setProperty(Context *cx, const String &name, NamespaceList
     else {
         PropertyIterator it = findNamespacedProperty(name, names);
         if (it == mProperties.end())
-            insertNewProperty(name, names, 0, Object_Type, v);
+            insertNewProperty(name, names, Property::Enumerable, Object_Type, v);
         else {
             Property *prop = PROPERTY(it);
             ASSERT(prop->mFlag == ValuePointer);
@@ -570,18 +573,21 @@ void JSStringInstance::getProperty(Context *cx, const String &name, NamespaceLis
 
 // construct an instance of a type
 // - allocate memory for the slots, load the instance variable names into the 
-// property map. 
+// property map - in order to provide dynamic access to those properties.
 void JSInstance::initInstance(Context *cx, JSType *type)
 {
     if (type->mVariableCount)
         mInstanceValues = new JSValue[type->mVariableCount];
 
-    // copy the instance variable names into the property map
+    // copy the instance variable names into the property map 
+    // but don't copy the prototype object (XXX others?)
     for (PropertyIterator pi = type->mProperties.begin(), 
                 end = type->mProperties.end();
-                (pi != end); pi++) {            
-        const PropertyMap::value_type e(PROPERTY_NAME(pi), NAMESPACED_PROPERTY(pi));
-        mProperties.insert(e);
+                (pi != end); pi++) {
+        if (PROPERTY_NAME(pi) != cx->Prototype_StringAtom) {
+            const PropertyMap::value_type e(PROPERTY_NAME(pi), NAMESPACED_PROPERTY(pi));
+            mProperties.insert(e);
+        }
     }
 
     // and then do the same for the super types
@@ -590,8 +596,10 @@ void JSInstance::initInstance(Context *cx, JSType *type)
         for (PropertyIterator i = t->mProperties.begin(), 
                     end = t->mProperties.end();
                     (i != end); i++) {            
-            const PropertyMap::value_type e(PROPERTY_NAME(i), NAMESPACED_PROPERTY(i));
-            mProperties.insert(e);            
+            if (PROPERTY_NAME(i) != cx->Prototype_StringAtom) {
+                const PropertyMap::value_type e(PROPERTY_NAME(i), NAMESPACED_PROPERTY(i));
+                mProperties.insert(e);
+            }
         }
         if (t->mInstanceInitializer)
             cx->invokeFunction(t->mInstanceInitializer, JSValue(this), NULL, 0);
@@ -654,9 +662,8 @@ JSInstance *JSStringType::newInstance(Context *cx)
 
 // don't add to instances etc., climb all the way down (likely to the global object)
 // and add the property there.
-void ScopeChain::setNameValue(Context *cx, const String& name, AttributeStmtNode *attr)
+void ScopeChain::setNameValue(Context *cx, const String& name, NamespaceList *names)
 {
-    NamespaceList *names = (attr) ? attr->attributeValue->mNamespaceList : NULL;
     JSValue v = cx->topValue();
     for (ScopeScanner s = mScopeStack.rbegin(), end = mScopeStack.rend(); (s != end); s++)
     {
@@ -676,12 +683,11 @@ void ScopeChain::setNameValue(Context *cx, const String& name, AttributeStmtNode
             return;
         }
     }
-    cx->getGlobalObject()->defineVariable(cx, name, attr, Object_Type, v);
+    cx->getGlobalObject()->defineVariable(cx, name, names, 0, Object_Type, v);
 }
 
-bool ScopeChain::deleteName(Context *, const String& name, AttributeStmtNode *attr)
+bool ScopeChain::deleteName(Context *, const String& name, NamespaceList *names)
 {
-    NamespaceList *names = (attr) ? attr->attributeValue->mNamespaceList : NULL;
     for (ScopeScanner s = mScopeStack.rbegin(), end = mScopeStack.rend(); (s != end); s++)
     {
         PropertyIterator i;
@@ -693,9 +699,8 @@ bool ScopeChain::deleteName(Context *, const String& name, AttributeStmtNode *at
 
 inline char narrow(char16 ch) { return char(ch); }
 
-JSObject *ScopeChain::getNameValue(Context *cx, const String& name, AttributeStmtNode *attr)
+JSObject *ScopeChain::getNameValue(Context *cx, const String& name, NamespaceList *names)
 {
-    NamespaceList *names = (attr) ? attr->attributeValue->mNamespaceList : NULL;
     uint32 depth = 0;
     for (ScopeScanner s = mScopeStack.rbegin(), end = mScopeStack.rend(); (s != end); s++, depth++)
     {
@@ -1083,7 +1088,7 @@ void ScopeChain::collectNames(StmtNode *p)
                 JSType *theClass = topClass();
                 if (theClass == NULL)
                     m_cx->reportError(Exception::typeError, "Private can only be used inside a class");
-                vs->attributeValue->mNamespaceList = new NamespaceList(theClass->mPrivateNamespace, vs->attributeValue->mNamespaceList);
+                vs->attributeValue->mNamespaceList = new NamespaceList(*theClass->mPrivateNamespace, vs->attributeValue->mNamespaceList);
             }
 
             while (v)  {
@@ -1118,7 +1123,7 @@ void ScopeChain::collectNames(StmtNode *p)
             */
             if (!isPrototype
                     && (!isOperator)
-		    && isPossibleUncheckedFunction(f->function)) {
+                    && isPossibleUncheckedFunction(f->function)) {
                 isPrototype = true;
                 fnc->setIsUnchecked();
             }
@@ -1229,7 +1234,7 @@ void ScopeChain::collectNames(StmtNode *p)
         {
             NamespaceStmtNode *n = checked_cast<NamespaceStmtNode *>(p);
             Attribute *x = new Attribute(0, 0);
-            x->mNamespaceList = new NamespaceList(&n->name, x->mNamespaceList);
+            x->mNamespaceList = new NamespaceList(n->name, x->mNamespaceList);
             m_cx->getGlobalObject()->defineVariable(m_cx, n->name, (NamespaceList *)(NULL), Property::NoAttribute, Attribute_Type, JSValue(x));            
         }
         break;
@@ -1275,22 +1280,6 @@ void JSType::completeClass(Context *cx, ScopeChain *scopeChain)
     }
 }
 
-/*
-// constructor functions are added as static methods
-// XXX is it worth just having a default constructor 
-// pointer in the class?
-JSFunction *JSType::getDefaultConstructor()
-{
-    PropertyIterator it;
-    if (hasOwnProperty(*mClassName, NULL, Read, &it)) {
-        ASSERT(PROPERTY_KIND(it) == ValuePointer);
-        JSValue c = *PROPERTY_VALUEPOINTER(it);
-        ASSERT(c.isFunction());
-        return c.function;
-    }
-    return NULL;
-}
-*/
 void JSType::defineMethod(Context *cx, const String& name, AttributeStmtNode *attr, JSFunction *f)
 {
     NamespaceList *names = (attr) ? attr->attributeValue->mNamespaceList : NULL;
@@ -1452,23 +1441,25 @@ JSType::JSType(Context *cx, const StringAtom *name, JSType *super, JSObject *pro
     for (uint32 i = 0; i < OperatorCount; i++)
         mUnaryOperators[i] = NULL;
 
-    // every class gets a prototype object
+    // every class gets a prototype object (used to set the __proto__ value of new instances)
     if (protoObj)
         mPrototypeObject = protoObj;
-    else
+    else {
         mPrototypeObject = new JSObject(this);
-    // and that object is prototype-linked to the super-type's prototype object
-    if (mSuperType)
-        mPrototypeObject->mPrototype = mSuperType->mPrototypeObject;
+        // and that object is prototype-linked to the super-type's prototype object
+        if (mSuperType)
+            mPrototypeObject->mPrototype = mSuperType->mPrototypeObject;
+    }
 
     if (mSuperType)
         defineVariable(cx, cx->Prototype_StringAtom, (NamespaceList *)NULL, Property::ReadOnly | Property::DontDelete, Object_Type, JSValue(mPrototypeObject));
-    else  // must be Object_Type
+    else  // must be Object_Type being initialized
         defineVariable(cx, cx->Prototype_StringAtom, (NamespaceList *)NULL, Property::ReadOnly | Property::DontDelete, this, JSValue(mPrototypeObject));
 
+    // the __proto__ of a type is the super-type's prototype object, or for 'class Object' type object it's the Object's prototype object
     if (mSuperType)
         mPrototype = mSuperType->mPrototypeObject;
-    else // must be Object_Type
+    else // must be Object_Type being initialized
         mPrototype = mPrototypeObject;
 }
 
@@ -1545,7 +1536,7 @@ Reference *Activation::genReference(bool /* hasBase */, const String& name, Name
                 return new LocalVarReference(prop->mData.index, acc, prop->mType, prop->mAttributes);
 
         case ValuePointer:
-            return new NameReference(name, acc, prop->mType, prop->mAttributes);
+            return new NameReference(name, names, acc, prop->mType, prop->mAttributes);
 
         default:            
             NOT_REACHED("bad genRef call");
@@ -1945,7 +1936,7 @@ static JSValue Function_Constructor(Context *cx, const JSValue& thisValue, JSVal
 
 
         if (cx->mScopeChain->isPossibleUncheckedFunction(f->function)) {
-	    fnc->setIsPrototype(true);
+            fnc->setIsPrototype(true);
             fnc->setIsUnchecked();
         }
         cx->buildRuntimeForFunction(f->function, fnc);
@@ -2182,6 +2173,163 @@ static JSValue GenericError_Constructor(Context *cx, const JSValue& thisValue, J
     return v;
 }
 
+JSValue RegExp_Constructor(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
+{
+    JSValue thatValue = thisValue;
+    if (thatValue.isNull())
+        thatValue = RegExp_Type->newInstance(cx);
+    ASSERT(thatValue.isObject());
+    JSObject *thisObj = thatValue.object;
+
+    const String *regexpStr = &cx->Empty_StringAtom;
+    const String *flagStr = &cx->Empty_StringAtom;
+    if (argc > 0) {
+        if (argv[0].isObject() && (argv[0].object->mType == RegExp_Type)) {
+            if ((argc == 1) || argv[1].isUndefined()) {
+                ContextStackReplacement csr(cx);
+                argv[0].object->getProperty(cx, cx->Source_StringAtom, CURRENT_ATTR);
+                JSValue src = cx->popValue();
+                ASSERT(src.isString());
+                regexpStr = src.string;
+		REParseState *other = (REParseState *)(argv[0].object->mPrivate);
+		String *newFlagStr = new String;
+		if (other->flags & GLOBAL) *newFlagStr += "g";
+		if (other->flags & IGNORECASE) *newFlagStr += "i";
+		if (other->flags & MULTILINE) *newFlagStr += "m";
+		flagStr = newFlagStr;
+            }
+            else
+                cx->reportError(Exception::typeError, "Illegal RegExp constructor args");
+        }
+        else
+            regexpStr = argv[0].toString(cx).string;
+        if ((argc > 1) && !argv[1].isUndefined())
+            flagStr = argv[1].toString(cx).string;
+    }
+    REParseState *parseResult = REParse(regexpStr->c_str(), regexpStr->length(), flagStr->c_str(), flagStr->length(), false);
+    if (parseResult) {
+        thisObj->mPrivate = parseResult;
+// XXX ECMA spec says these are DONTENUM, but SpiderMonkey and test suite disagree
+/*
+        thisObj->defineVariable(cx, cx->Source_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly), String_Type, JSValue(regexpStr));
+        thisObj->defineVariable(cx, cx->Global_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly), Boolean_Type, (parseResult->flags & GLOBAL) ? kTrueValue : kFalseValue);
+        thisObj->defineVariable(cx, cx->IgnoreCase_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly), Boolean_Type, (parseResult->flags & IGNORECASE) ? kTrueValue : kFalseValue);
+        thisObj->defineVariable(cx, cx->Multiline_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly), Boolean_Type, (parseResult->flags & MULTILINE) ? kTrueValue : kFalseValue);
+        thisObj->defineVariable(cx, cx->LastIndex_StringAtom, NULL, Property::DontDelete, Number_Type, kPositiveZero);
+*/
+        thisObj->defineVariable(cx, cx->Source_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly | Property::Enumerable), String_Type, JSValue(regexpStr));
+        thisObj->defineVariable(cx, cx->Global_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly | Property::Enumerable), Boolean_Type, (parseResult->flags & GLOBAL) ? kTrueValue : kFalseValue);
+        thisObj->defineVariable(cx, cx->IgnoreCase_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly | Property::Enumerable), Boolean_Type, (parseResult->flags & IGNORECASE) ? kTrueValue : kFalseValue);
+        thisObj->defineVariable(cx, cx->Multiline_StringAtom, NULL, (Property::DontDelete | Property::ReadOnly | Property::Enumerable), Boolean_Type, (parseResult->flags & MULTILINE) ? kTrueValue : kFalseValue);
+        thisObj->defineVariable(cx, cx->LastIndex_StringAtom, NULL, (Property::DontDelete | Property::Enumerable), Number_Type, kPositiveZero);
+    }
+    else {
+        cx->reportError(Exception::syntaxError, "Failed to parse RegExp : '{0}'", *regexpStr + "/" + *flagStr);  // XXX error message?
+    }
+    return thatValue;
+}
+
+JSValue RegExp_TypeCast(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
+{
+    if (argc > 0) {
+	if ((argv[0].isObject() && (argv[0].object->mType == RegExp_Type))
+		&& ((argc == 1) || argv[1].isUndefined()))
+	    return argv[0];
+    }
+    return RegExp_Constructor(cx, thisValue, argv, argc);
+}
+
+JSValue RegExp_toString(Context *cx, const JSValue& thisValue, JSValue * /*argv*/, uint32 /*argc*/)
+{
+    ContextStackReplacement csr(cx);
+    ASSERT(thisValue.isObject());
+    JSObject *thisObj = thisValue.object;
+    if (thisObj->mType != RegExp_Type)
+        cx->reportError(Exception::typeError, "RegExp.toString can only be applied to RegExp objects");
+    thisObj->getProperty(cx, cx->Source_StringAtom, CURRENT_ATTR);
+    JSValue src = cx->popValue();
+    
+    // XXX not ever expected this except in the one case of RegExp.prototype, which isn't a fully formed
+    // RegExp instance, but has the appropriate type pointer.
+    if (src.isUndefined()) {
+        ASSERT(thisObj == RegExp_Type->mPrototypeObject);
+        return JSValue(&cx->Empty_StringAtom);
+    }
+
+    String *result = new String("/" + *src.toString(cx).string + "/");
+    REParseState *state = (REParseState *)thisObj->mPrivate;
+    if (state->flags & GLOBAL) *result += "g";
+    if (state->flags & IGNORECASE) *result += "i";
+    if (state->flags & MULTILINE) *result += "m";
+
+    return JSValue(result);
+}
+
+JSValue RegExp_exec(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
+{
+    ASSERT(thisValue.isObject());
+    JSObject *thisObj = thisValue.object;
+    if (thisObj->mType != RegExp_Type)
+        cx->reportError(Exception::typeError, "RegExp.exec can only be applied to RegExp objects");
+    JSValue result = kNullValue;
+    if (argc > 0) {
+        ContextStackReplacement csr(cx);
+
+        thisObj->getProperty(cx, cx->LastIndex_StringAtom, CURRENT_ATTR);
+        JSValue lastIndex = cx->popValue();
+
+        REParseState *parseResult = (REParseState *)(thisObj->mPrivate);
+        parseResult->lastIndex = (int)(lastIndex.toInteger(cx).f64);
+
+        const String *str = argv[0].toString(cx).string;
+        REState *regexp_result = REExecute(parseResult, str->c_str(), str->length());
+        if (regexp_result) {
+            JSArrayInstance *resultArray = (JSArrayInstance *)Array_Type->newInstance(cx);
+            String *matchStr = new String(str->substr(regexp_result->endIndex, regexp_result->length));
+            resultArray->setProperty(cx, *numberToString(0), NULL, JSValue(matchStr));
+            String *parenStr = &cx->Empty_StringAtom;
+            for (uint32 i = 0; i < regexp_result->n; i++) {
+                if (regexp_result->parens[i].index != -1) {
+                    String *parenStr = new String(str->substr(regexp_result->parens[i].index, regexp_result->parens[i].length));
+                    resultArray->setProperty(cx, *numberToString(i + 1), NULL, JSValue(parenStr));
+                }
+            }
+            // XXX SpiderMonkey also adds 'index' and 'input' properties to the result
+            resultArray->setProperty(cx, cx->Index_StringAtom, CURRENT_ATTR, JSValue((float64)(regexp_result->endIndex)));
+            resultArray->setProperty(cx, cx->Input_StringAtom, CURRENT_ATTR, JSValue(str));
+            result = JSValue(resultArray);
+
+            // XXX Set up the SpiderMonkey 'RegExp statics'
+            RegExp_Type->setProperty(cx, cx->LastMatch_StringAtom, CURRENT_ATTR, JSValue(matchStr));
+            RegExp_Type->setProperty(cx, cx->LastParen_StringAtom, CURRENT_ATTR, JSValue(parenStr));            
+            String *contextStr = new String(str->substr(0, regexp_result->endIndex));
+            RegExp_Type->setProperty(cx, cx->LeftContext_StringAtom, CURRENT_ATTR, JSValue(contextStr));
+            uint32 matchEnd = regexp_result->endIndex + regexp_result->length;
+            contextStr = new String(str->substr(matchEnd, str->length() - matchEnd));
+            RegExp_Type->setProperty(cx, cx->RightContext_StringAtom, CURRENT_ATTR, JSValue(contextStr));
+        }
+        thisObj->setProperty(cx, cx->LastIndex_StringAtom, CURRENT_ATTR, JSValue((float64)(parseResult->lastIndex)));
+
+    }
+    return result;
+}
+
+JSValue RegExp_test(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
+{
+    ASSERT(thisValue.isObject());
+    JSObject *thisObj = thisValue.object;
+    if (thisObj->mType != RegExp_Type)
+        cx->reportError(Exception::typeError, "RegExp.test can only be applied to RegExp objects");
+    if (argc > 0) {
+        const String *str = argv[0].toString(cx).string;
+        REState *regexp_result = REExecute((REParseState *)(thisObj->mPrivate), str->c_str(), str->length());
+        if (regexp_result)
+            return kTrueValue;
+    }
+    return kFalseValue;
+}
+
+
 JSValue Error_Constructor(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
 {
     return GenericError_Constructor(cx, thisValue, argv, argc, Error_Type);
@@ -2616,6 +2764,7 @@ void Context::initBuiltins()
         { "SyntaxError",    SyntaxError_Constructor,    &kNullValue          },
         { "TypeError",      TypeError_Constructor,      &kNullValue          },
         { "UriError",       UriError_Constructor,       &kNullValue          },
+        { "RegExp",         RegExp_Constructor,         &kNullValue          },
     };
 
     Object_Type  = new JSType(this, &mWorld.identifiers[widenCString(builtInClasses[0].name)], NULL);
@@ -2667,8 +2816,11 @@ void Context::initBuiltins()
     SyntaxError_Type    = new JSType(this, &mWorld.identifiers[widenCString(builtInClasses[18].name)], Error_Type);
     TypeError_Type      = new JSType(this, &mWorld.identifiers[widenCString(builtInClasses[19].name)], Error_Type);
     UriError_Type       = new JSType(this, &mWorld.identifiers[widenCString(builtInClasses[20].name)], Error_Type);
+    
+    // XXX RegExp.prototype is set to a RegExp instance, which isn't ECMA (it's supposed to be an Object instance) bu
+    // is SpiderMonkey compatible.
+    RegExp_Type         = new JSType(this, &mWorld.identifiers[widenCString(builtInClasses[21].name)], Object_Type);
 
-    String_Type->defineVariable(this, FromCharCode_StringAtom, NULL, String_Type, JSValue(new JSFunction(this, String_fromCharCode, String_Type)));
 
 
     ProtoFunDef objectProtos[] = 
@@ -2716,6 +2868,14 @@ void Context::initBuiltins()
         { "toSource", String_Type, 0, Error_toString },
         { NULL }
     };
+    ProtoFunDef regexpProtos[] = 
+    {
+        { "toString", String_Type, 0, RegExp_toString },
+        { "toSource", String_Type, 0, RegExp_toString },
+        { "exec",     Array_Type,  0, RegExp_exec },
+        { "test",     Boolean_Type,0, RegExp_test },
+        { NULL }
+    };
 
     ASSERT(mGlobal);
     *mGlobal = Object_Type->newInstance(this);
@@ -2735,12 +2895,13 @@ void Context::initBuiltins()
     initClass(Date_Type,            &builtInClasses[12], getDateProtos() );
     initClass(Null_Type,            &builtInClasses[13], NULL);
     initClass(Error_Type,           &builtInClasses[14], new PrototypeFunctions(&errorProtos[0]));
-    initClass(EvalError_Type,       &builtInClasses[15], new PrototypeFunctions(&errorProtos[0]));
+    initClass(EvalError_Type,       &builtInClasses[15], new PrototypeFunctions(&errorProtos[0]));  // XXX shouldn't these be inherited from prototype?
     initClass(RangeError_Type,      &builtInClasses[16], new PrototypeFunctions(&errorProtos[0]));
     initClass(ReferenceError_Type,  &builtInClasses[17], new PrototypeFunctions(&errorProtos[0]));
     initClass(SyntaxError_Type,     &builtInClasses[18], new PrototypeFunctions(&errorProtos[0]));
     initClass(TypeError_Type,       &builtInClasses[19], new PrototypeFunctions(&errorProtos[0]));
     initClass(UriError_Type,        &builtInClasses[20], new PrototypeFunctions(&errorProtos[0]));
+    initClass(RegExp_Type,          &builtInClasses[21], new PrototypeFunctions(&regexpProtos[0]));
 
     Type_Type->defineUnaryOperator(Index, new JSFunction(this, arrayMaker, Type_Type));
     
@@ -2759,9 +2920,19 @@ void Context::initBuiltins()
     Date_Type->defineStaticMethod(this, widenCString("parse"), NULL, new JSFunction(this, Date_parse, Number_Type));
     Date_Type->defineStaticMethod(this, widenCString("UTC"), NULL, new JSFunction(this, Date_UTC, Number_Type));
 
+    String_Type->defineVariable(this, FromCharCode_StringAtom, NULL, String_Type, JSValue(new JSFunction(this, String_fromCharCode, String_Type)));
     String_Type->mTypeCast = new JSFunction(this, String_TypeCast, String_Type);
 
     Error_Type->mTypeCast = new JSFunction(this, Error_Constructor, Error_Type);
+    RegExp_Type->mTypeCast = new JSFunction(this, RegExp_TypeCast, Error_Type);
+
+    // XXX these RegExp statics are not specified by ECMA, but implemented by SpiderMonkey
+    RegExp_Type->defineVariable(this, Input_StringAtom, NULL, Property::NoAttribute, String_Type, JSValue(&Empty_StringAtom));
+    RegExp_Type->defineVariable(this, LastMatch_StringAtom, NULL, Property::NoAttribute, String_Type, JSValue(&Empty_StringAtom));
+    RegExp_Type->defineVariable(this, LastParen_StringAtom, NULL, Property::NoAttribute, String_Type, JSValue(&Empty_StringAtom));
+    RegExp_Type->defineVariable(this, LeftContext_StringAtom, NULL, Property::NoAttribute, String_Type, JSValue(&Empty_StringAtom));
+    RegExp_Type->defineVariable(this, RightContext_StringAtom, NULL, Property::NoAttribute, String_Type, JSValue(&Empty_StringAtom));
+    
 
 }
 
@@ -2872,6 +3043,18 @@ Context::Context(JSObject **global, World &world, Arena &a, Pragma::Flags flags)
       SyntaxError_StringAtom    (world.identifiers["SyntaxError"]),
       TypeError_StringAtom      (world.identifiers["TypeError"]),
       UriError_StringAtom       (world.identifiers["UriError"]),
+      Source_StringAtom         (world.identifiers["source"]),
+      Global_StringAtom         (world.identifiers["global"]),
+      IgnoreCase_StringAtom     (world.identifiers["ignoreCase"]),
+      Multiline_StringAtom      (world.identifiers["multiline"]),
+      Input_StringAtom          (world.identifiers["input"]),
+      Index_StringAtom          (world.identifiers["index"]),
+      LastIndex_StringAtom      (world.identifiers["lastIndex"]),
+      LastMatch_StringAtom      (world.identifiers["lastMatch"]),
+      LastParen_StringAtom      (world.identifiers["lastParen"]),
+      LeftContext_StringAtom    (world.identifiers["leftContext"]),
+      RightContext_StringAtom   (world.identifiers["rightContext"]),
+      Dollar_StringAtom		(world.identifiers["$"]),
 
       mWorld(world),
       mScopeChain(NULL),
@@ -2884,6 +3067,7 @@ Context::Context(JSObject **global, World &world, Arena &a, Pragma::Flags flags)
       mStack(NULL),
       mStackTop(0),
       mStackMax(0),
+      mNamespaceList(NULL),
       mLocals(NULL),
       mArgumentBase(NULL),
       mReader(NULL),
diff --git a/mozilla/js2/src/js2runtime.h b/mozilla/js2/src/js2runtime.h
index 66dfb18123a..dda5425b7e1 100644
--- a/mozilla/js2/src/js2runtime.h
+++ b/mozilla/js2/src/js2runtime.h
@@ -120,6 +120,7 @@ static const double two31 = 2147483648.0;
     extern JSType *NamedArgument_Type;
 
     extern JSType *Date_Type;
+    extern JSType *RegExp_Type;
 
 
     const String *numberToString(float64 number);
@@ -443,10 +444,11 @@ XXX ...couldn't get this to work...
     // the "we don't know any field by that name".
     class PropertyReference : public Reference {
     public:
-        PropertyReference(const String& name, Access acc, JSType *type, PropertyAttribute attr)
-            : Reference(type, attr), mAccess(acc), mName(name) { }
+        PropertyReference(const String& name, NamespaceList *nameSpace, Access acc, JSType *type, PropertyAttribute attr)
+            : Reference(type, attr), mAccess(acc), mName(name), mNameSpace(nameSpace) { }
         Access mAccess;
         const String& mName;
+        NamespaceList *mNameSpace;
         void emitCodeSequence(ByteCodeGen *bcg);
         void emitInvokeSequence(ByteCodeGen *bcg);
         uint16 baseExpressionDepth() { return 1; }
@@ -468,12 +470,13 @@ XXX ...couldn't get this to work...
     // so it's a scope chain lookup at runtime
     class NameReference : public Reference {
     public:
-        NameReference(const String& name, Access acc)
-            : Reference(Object_Type, 0), mAccess(acc), mName(name) { }
-        NameReference(const String& name, Access acc, JSType *type, PropertyAttribute attr)
-            : Reference(type, attr), mAccess(acc), mName(name) { }
+        NameReference(const String& name, NamespaceList *nameSpace, Access acc)
+            : Reference(Object_Type, 0), mAccess(acc), mName(name), mNameSpace(nameSpace) { }
+        NameReference(const String& name, NamespaceList *nameSpace, Access acc, JSType *type, PropertyAttribute attr)
+            : Reference(type, attr), mAccess(acc), mName(name), mNameSpace(nameSpace) { }
         Access mAccess;
         const String& mName;
+        NamespaceList *mNameSpace;
         void emitCodeSequence(ByteCodeGen *bcg);
         void emitTypeOf(ByteCodeGen *bcg);
         void emitDelete(ByteCodeGen *bcg);
@@ -777,6 +780,7 @@ XXX ...couldn't get this to work...
 
         // the 'vtable'
         MethodList          mMethods;
+
         const StringAtom    *mClassName;
         const StringAtom    *mPrivateNamespace;
 
@@ -796,7 +800,7 @@ XXX ...couldn't get this to work...
 
     class JSArrayInstance : public JSInstance {
     public:
-        JSArrayInstance(Context *cx, JSType * /*type*/) : JSInstance(cx, NULL), mLength(0) { mType = (JSType *)Array_Type; }
+        JSArrayInstance(Context *cx, JSType * /*type*/) : JSInstance(cx, NULL), mLength(0) { mType = (JSType *)Array_Type; mPrototype = Object_Type->mPrototypeObject; }
         virtual ~JSArrayInstance() { } // keeping gcc happy
 
 #ifdef DEBUG
@@ -918,14 +922,16 @@ XXX ...couldn't get this to work...
                         mStackTop(0),
                         mPC(0), 
                         mModule(NULL),
-                        mContainer(NULL) { }
+                        mNamespaceList(NULL),
+                        mContainer(NULL)       { }
 
         Activation(JSValue *locals, 
                         JSValue *stack, uint32 stackTop,
                         ScopeChain *scopeChain,
                         JSValue *argBase, JSValue curThis,
                         uint8 *pc, 
-                        ByteCodeModule *module )
+                        ByteCodeModule *module,
+                        NamespaceList *namespaceList )
                     : JSType(NULL), 
                         mLocals(locals), 
                         mStack(stack), 
@@ -935,6 +941,7 @@ XXX ...couldn't get this to work...
                         mThis(curThis), 
                         mPC(pc), 
                         mModule(module),
+                        mNamespaceList(namespaceList),
                         mContainer(NULL)       { }
 
         virtual ~Activation() { } // keeping gcc happy
@@ -964,6 +971,7 @@ XXX ...couldn't get this to work...
         uint8 *mPC;
         ByteCodeModule *mModule;
         JSFunction *mContainer;
+        NamespaceList *mNamespaceList;
 
         virtual JSFunction *getContainerFunction()      { return mContainer; }
 
@@ -1083,7 +1091,7 @@ XXX ...couldn't get this to work...
             return top->hasProperty(name, names, acc, p);
         }
 
-        bool deleteName(Context *cx, const String& name, AttributeStmtNode *attr);
+        bool deleteName(Context *cx, const String& name, NamespaceList *names);
 /*
         bool hasOwnProperty(const String& name, NamespaceList *names, Access acc, PropertyIterator *p)
         {
@@ -1104,7 +1112,7 @@ XXX ...couldn't get this to work...
         bool hasNameValue(const String& name, NamespaceList *names);
 
         // pushes the value of the name and returns it's container object
-        JSObject *getNameValue(Context *cx, const String& name, AttributeStmtNode *attr);
+        JSObject *getNameValue(Context *cx, const String& name, NamespaceList *names);
 
         // return the class on the top of the stack (or NULL if there
         // isn't one there).
@@ -1142,7 +1150,7 @@ XXX ...couldn't get this to work...
 
 
 
-        void setNameValue(Context *cx, const String& name, AttributeStmtNode *attr);
+        void setNameValue(Context *cx, const String& name, NamespaceList *names);
 
         // return the number of local vars used by all the 
         // Activations on the top of the chain
@@ -1398,7 +1406,6 @@ XXX ...couldn't get this to work...
 
 
 
-
     // provide access to the Error object constructors so that runtime exceptions
     // can be constructed for Javascript catches.
     extern JSValue Error_Constructor(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc);
@@ -1409,6 +1416,12 @@ XXX ...couldn't get this to work...
     extern JSValue TypeError_Constructor(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc);
     extern JSValue UriError_Constructor(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc);
 
+    // called by bytecodegen for RegExp literals
+    extern JSValue RegExp_Constructor(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc);
+    
+    // called directly by String.match
+    extern JSValue RegExp_exec(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc);
+
     class Attribute;
     
     class Context {
@@ -1494,6 +1507,18 @@ XXX ...couldn't get this to work...
         StringAtom& SyntaxError_StringAtom;
         StringAtom& TypeError_StringAtom;
         StringAtom& UriError_StringAtom;
+        StringAtom& Source_StringAtom;
+        StringAtom& Global_StringAtom;
+        StringAtom& IgnoreCase_StringAtom;
+        StringAtom& Multiline_StringAtom;
+        StringAtom& Input_StringAtom;
+        StringAtom& Index_StringAtom;
+        StringAtom& LastIndex_StringAtom;
+        StringAtom& LastMatch_StringAtom;
+        StringAtom& LastParen_StringAtom;
+        StringAtom& LeftContext_StringAtom;
+        StringAtom& RightContext_StringAtom;
+	StringAtom& Dollar_StringAtom;
 
         void initBuiltins();
         void initClass(JSType *type, ClassDef *cdef, PrototypeFunctions *pdef);
@@ -1546,6 +1571,8 @@ XXX ...couldn't get this to work...
         uint32 mStackTop;
         uint32 mStackMax;
 
+        NamespaceList *mNamespaceList;
+
         void pushValue(const JSValue &v)
         {
             ASSERT(mStackTop < mStackMax);
diff --git a/mozilla/js2/src/jsstring.cpp b/mozilla/js2/src/jsstring.cpp
index 2c2feb8184f..ad73d89aeea 100644
--- a/mozilla/js2/src/jsstring.cpp
+++ b/mozilla/js2/src/jsstring.cpp
@@ -45,6 +45,7 @@
 #include "js2runtime.h"
 
 #include "jsstring.h"
+#include "regexp.h"
 
 namespace JavaScript {    
 namespace JS2Runtime {
@@ -105,6 +106,170 @@ static JSValue String_valueOf(Context *cx, const JSValue& thisValue, JSValue * /
 }
 
 
+static JSValue String_match(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
+{
+    ContextStackReplacement csr(cx);
+
+    ASSERT(thisValue.isObject() || thisValue.isFunction() || thisValue.isType());
+    JSValue S = thisValue.toString(cx);
+
+    JSValue regexp = argv[0];
+    if ((argc == 0) || !regexp.isObject() || (regexp.object->mType != RegExp_Type)) {
+        regexp = kNullValue;
+        regexp = RegExp_Constructor(cx, regexp, argv, 1);
+    }
+
+    REParseState *parseResult = (REParseState *)(regexp.object->mPrivate);
+    if ((parseResult->flags & GLOBAL) == 0) {
+        return RegExp_exec(cx, regexp, &S, 1);                
+    }
+    else {
+        JSArrayInstance *A = (JSArrayInstance *)Array_Type->newInstance(cx);
+        parseResult->lastIndex = 0;
+        uint32 index = 0;
+        while (true) {
+            REState *regexp_result = REExecute(parseResult, S.string->c_str(), S.string->length());
+            if (regexp_result == NULL)
+                break;
+            if (parseResult->lastIndex == index)
+                parseResult->lastIndex++;
+            String *matchStr = new String(S.string->substr(regexp_result->endIndex, regexp_result->length));
+            A->setProperty(cx, *numberToString(index++), NULL, JSValue(matchStr));
+        }
+        regexp.object->setProperty(cx, cx->LastIndex_StringAtom, NULL, JSValue((float64)(parseResult->lastIndex)));
+        return JSValue(A);
+    }
+}
+
+const String interpretDollar(Context *cx, const String *replaceStr, uint32 dollarPos, const String *searchStr, REState *regexp_result, uint32 &skip)
+{
+    skip = 2;
+    const char16 *dollarValue = replaceStr->c_str() + dollarPos + 1;
+    switch (*dollarValue) {
+    case '$':
+	return cx->Dollar_StringAtom;
+    case '&':
+	return searchStr->substr(regexp_result->endIndex, regexp_result->length);
+    case '`':
+	return searchStr->substr(0, regexp_result->endIndex);
+    case '\'':
+	{
+	    uint32 matchEndIndex = regexp_result->endIndex + regexp_result->length;
+	    return searchStr->substr(matchEndIndex, searchStr->length() - matchEndIndex);
+	}
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+	{
+	    uint32 num = *dollarValue - '0';
+	    if (num <= regexp_result->n) {
+		if ((dollarPos < (replaceStr->length() - 2))
+			&& (dollarValue[1] >= '0') && (dollarValue[1] <= '9')) {
+		    uint32 tmp = (num * 10) + (dollarValue[1] - '0');
+		    if (tmp <= regexp_result->n) {
+			num = tmp;
+			skip = 3;
+		    }
+		}
+		return searchStr->substr(regexp_result->parens[num - 1].index, regexp_result->parens[num - 1].length);
+	    }
+	}
+	// fall thru
+    default:
+	skip = 1;
+	return cx->Dollar_StringAtom;
+    }
+}
+
+static JSValue String_replace(Context *cx, const JSValue& thisValue, JSValue *argv, uint32 argc)
+{
+    ASSERT(thisValue.isObject() || thisValue.isFunction() || thisValue.isType());
+    JSValue S = thisValue.toString(cx);
+
+    JSValue searchValue;
+    JSValue replaceValue;
+
+    if (argc > 0) searchValue = argv[0];
+    if (argc > 1) replaceValue = argv[1];
+    const String *replaceStr = replaceValue.toString(cx).string;
+
+    if (searchValue.isObject() && (searchValue.object->mType == RegExp_Type)) {
+	REParseState *parseResult = (REParseState *)(searchValue.object->mPrivate);
+	REState *regexp_result;
+	uint32 m = parseResult->parenCount;
+	String newString;
+        uint32 index = 0;
+
+	while (true) {
+	    if (parseResult->flags & GLOBAL)
+		parseResult->lastIndex = index;
+            regexp_result = REExecute(parseResult, S.string->c_str(), S.string->length());
+	    if (regexp_result) {
+		String insertString;
+		uint32 start = 0;
+		while (true) {
+		    uint32 dollarPos = replaceStr->find('$', start);
+		    if ((dollarPos != String::npos) && (dollarPos < (replaceStr->length() - 1))) {
+			uint32 skip;
+			insertString += replaceStr->substr(start, dollarPos - start);
+			insertString += interpretDollar(cx, replaceStr, dollarPos, S.string, regexp_result, skip);
+			start = dollarPos + skip;
+		    }
+		    else {
+			insertString += replaceStr->substr(start, replaceStr->length() - start);
+			break;
+		    }
+		}
+		newString += S.string->substr(index, regexp_result->endIndex - index);
+		newString += insertString;
+	    }
+	    else
+		break;
+	    index = regexp_result->endIndex + regexp_result->length;
+	    if ((parseResult->flags & GLOBAL) == 0)
+		break;
+	}
+	newString += S.string->substr(index, S.string->length() - index);
+	return JSValue(new String(newString));
+    }
+    else {
+	const String *searchStr = searchValue.toString(cx).string;
+	REState regexp_result;
+	regexp_result.endIndex = S.string->find(*searchStr, 0);
+	if (regexp_result.endIndex == String::npos)
+	    return JSValue(S.string);
+	regexp_result.length = searchStr->length();
+	regexp_result.n = 0;
+	String insertString;
+	String newString;
+	uint32 start = 0;
+	while (true) {
+	    uint32 dollarPos = replaceStr->find('$', start);
+	    if ((dollarPos != String::npos) && (dollarPos < (replaceStr->length() - 1))) {
+		uint32 skip;
+		insertString += replaceStr->substr(start, dollarPos - start);
+		insertString += interpretDollar(cx, replaceStr, dollarPos, S.string, &regexp_result, skip);
+		start = dollarPos + skip;
+	    }
+	    else {
+		insertString += replaceStr->substr(start, replaceStr->length() - start);
+		break;
+	    }
+	}
+	newString += S.string->substr(0, regexp_result.endIndex);
+	newString += insertString;
+	uint32 index = regexp_result.endIndex + regexp_result.length;
+	newString += S.string->substr(index, S.string->length() - index);
+	return JSValue(new String(newString));
+    }
+}
 
 struct MatchResult {
     bool failure;
@@ -258,14 +423,16 @@ static JSValue String_indexOf(Context *cx, const JSValue& thisValue, JSValue *ar
     uint32 pos = 0;
 
     if (argc > 1) {
-        int32 arg1 = (int32)(argv[1].toInt32(cx).f64);
-        if (arg1 < 0)
+        float64 fpos = argv[1].toNumber(cx).f64;
+        if (JSDOUBLE_IS_NaN(fpos))
+            pos = 0;
+        if (fpos < 0)
             pos = 0;
         else
-            if ((uint32)arg1 >= str->size()) 
+            if (fpos >= str->size()) 
                 pos = str->size();
             else
-                pos = (uint32)arg1;
+                pos = (uint32)(fpos);
     }
     pos = str->find(*searchStr, pos);
     if (pos == String::npos)
@@ -447,6 +614,8 @@ Context::PrototypeFunctions *getStringProtos()
         { "indexOf",            Number_Type, 1, String_indexOf },
         { "lastIndexOf",        Number_Type, 2, String_lastIndexOf },   // XXX ECMA spec says 1, but tests want 2 XXX
         { "localeCompare",      Number_Type, 1, String_localeCompare },
+        { "match",              Array_Type,  1, String_match },
+        { "replace",            String_Type, 2, String_replace },
         { "slice",              String_Type, 2, String_slice },
         { "split",              Array_Type,  1, String_split },         // XXX ECMA spec says 2, but tests want 1 XXX
         { "substring",          String_Type, 2, String_substring },
diff --git a/mozilla/js2/src/lexer.cpp b/mozilla/js2/src/lexer.cpp
index 2544d122e2a..2c07b994ec9 100644
--- a/mozilla/js2/src/lexer.cpp
+++ b/mozilla/js2/src/lexer.cpp
@@ -284,11 +284,14 @@ char16 JS::Lexer::lexEscape(bool unicodeOnly)
                 return static_cast<char16>(n);
             }
           default:
+/*
             if (!reader.getEof(ch)) {
                 CharInfo chi(ch);
                 if (!isAlphanumeric(chi) && !isLineBreak(chi))
                     return ch;
             }
+*/
+              return ch;
         }
   error:
     syntaxError("Bad escape code");
diff --git a/mozilla/js2/src/property.h b/mozilla/js2/src/property.h
index c3119dbd696..0348d8dc2b0 100644
--- a/mozilla/js2/src/property.h
+++ b/mozilla/js2/src/property.h
@@ -133,9 +133,9 @@ namespace JS2Runtime {
     Formatter& operator<<(Formatter& f, const Property& prop);
    
     struct NamespaceList {
-        NamespaceList(const StringAtom *name, NamespaceList *next) : mName(name), mNext(next) { }
+        NamespaceList(const StringAtom &name, NamespaceList *next) : mName(name), mNext(next) { }
 
-        const StringAtom *mName;
+        const StringAtom &mName;
         NamespaceList *mNext;
     };
 
diff --git a/mozilla/js2/src/regexp/regexp.c b/mozilla/js2/src/regexp/regexp.c
new file mode 100644
index 00000000000..63fadd8b659
--- /dev/null
+++ b/mozilla/js2/src/regexp/regexp.c
@@ -0,0 +1,1991 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifdef STANDALONE
+#include <stdio.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef ASSERT
+#include <assert.h>
+#define ASSERT assert
+#endif
+
+#include "RegExp.h"
+
+
+typedef unsigned char uint8;
+
+
+typedef enum REOp {
+    REOP_EMPTY,          /* an empty alternative */
+
+    REOP_ALT,           /* a tree of alternates */
+    REOP_NEXTALT,       /* continuation into thereof */
+
+    REOP_BOL,           /* start of line or input string '^' */
+    REOP_EOL,           /* end of line or input string '$' */
+
+    REOP_DOT,
+    REOP_CLASS,         /* '[...]' */
+
+    REOP_PAREN,         /* capturing */
+    REOP_CLOSEPAREN,    /* continuation for end of paren */
+    REOP_BACKREF,
+
+    REOP_WBND,          /* word boundary '\b' */
+    REOP_UNWBND,        /* not a word boundary '\B' */
+
+    REOP_ASSERT,        /* '(?= ... )' */
+    REOP_ASSERTNOT,     /* '(?! ... )' */
+    REOP_ASSERTTEST,    /* continuation point for above */
+
+    REOP_FLAT1,         /* single literal character */
+    REOP_FLATN,         /* multiple literal character */
+    REOP_FLAT1i,        /* case insensitive versions */
+    REOP_FLATNi,        /* of above */
+
+
+    REOP_DEC,           /* decimal digit '\d' */
+    REOP_UNDEC,         /* not a decimal digit '\D' */
+
+    REOP_WS,            /* whitespace or line terminator '\s' */
+    REOP_UNWS,          /* not whitespace '\S' */
+
+    REOP_LETDIG,        /* letter or digit or '_' '\w' */
+    REOP_UNLETDIG,      /* not letter or digit or '_' '\W' */
+
+    REOP_QUANT,         /* '+', '*', '?' or '{..}' */
+    REOP_REPEAT,        /* continuation into quant */
+    REOP_MINIMALREPEAT, /* continuation into quant */
+
+    REOP_END
+
+} REOp;
+
+#define RE_ISDEC(c)         ( (c >= '0') && (c <= '9') )
+#define RE_UNDEC(c)         (c - '0')
+
+#define RE_ISWS(c)          ( (c == ' ') || (c == '\t') || (c == '\n') || (c == '\r') )
+#define RE_ISLETTER(c)      ( ((c >= 'A') && (c <= 'Z')) || ((c >= 'a') && (c <= 'z')) )
+#define RE_ISLETDIG(c)      ( RE_ISLETTER(c) || RE_ISDEC(c) )
+
+#define RE_ISLINETERM(c)    ( (c == '\n') || (c == '\r') )
+
+
+typedef struct CharSet {
+    uint8 *bits;
+    REuint32 length;
+} CharSet;
+
+typedef struct REContinuationData {
+    REOp op;            /* not necessarily the same as node->kind */
+    RENode *node;
+
+    REuint32 min;         /* for quantifiers, record the current limits */
+    REuint32 max;
+
+    REuint32 index;       /* for assertions, record the match start */
+    REuint32 stackTop;    /* for assertions, record the backTrackStack */
+
+} REContinuationData;
+
+
+typedef struct RENode {
+
+    REContinuationData continuation;
+
+    REOp kind;
+
+    RENode *next;       /* links consecutive terms */
+
+    void *child;
+    
+    REuint32 parenIndex;
+
+    union {
+        void *child2;
+        struct {
+            REint32 min;
+            REint32 max;          /* -1 for infinity */
+            REbool greedy;    
+            REuint32 parenCount;  /* #parens in quantified term */
+        } quantifier;
+        REchar ch;
+        REuint32 length;
+        struct {
+            const REchar *end;
+            CharSet *charSet;
+            REbool sense;
+        } chclass;
+    } data;
+
+} RENode;
+
+
+typedef struct REGlobalData {
+    REuint32 flags;             /* flags from the RE in execution */   
+    REuint32 length;            /* length of input string */
+    const REchar *input;        /* the input string */
+    REError error;              /* runtime error code (out_of_memory only?) */
+} REGlobalData;
+
+
+
+typedef struct REBackTrackData {
+    REContinuationData continuation;
+    REState *state;
+} REBackTrackData;
+
+#define INITIAL_BACKTRACK (20)
+REuint32 maxBackTrack;
+REBackTrackData *backTrackStack = NULL;
+REuint32 backTrackStackTop;
+
+/*
+    Allocate space for a state and copy x into it.
+*/
+REState *copyState(REState *x)
+{
+    REState *result = (REState *)malloc(sizeof(REState) 
+                                            + (x->n * sizeof(RECapture)));
+    memcpy(result, x, sizeof(REState) + (x->n * sizeof(RECapture)));
+    return result;
+}
+
+/*
+    Copy state.
+*/
+void recoverState(REState *into, REState *from)
+{
+    memcpy(into, from, sizeof(REState) + (from->n * sizeof(RECapture)));
+}
+
+/*
+    Bottleneck for any errors.
+*/
+void reportRegExpError(REError *errP, REError err) 
+{
+    *errP = err;
+}
+
+/*
+    Push the back track data, growing the stack as necessary.
+*/
+REBackTrackData *pushBackTrack(REGlobalData *gData, REOp op, RENode *node, 
+                               REState *x)
+{
+    if (backTrackStackTop == maxBackTrack) {
+        maxBackTrack <<= 1;
+        backTrackStack = (REBackTrackData *)realloc(backTrackStack, 
+                                sizeof(REBackTrackData) * maxBackTrack);
+        if (!backTrackStack) {
+            reportRegExpError(&gData->error, OUT_OF_MEMORY);
+            return NULL;
+        }
+    }
+    backTrackStack[backTrackStackTop].continuation.op = op;
+    backTrackStack[backTrackStackTop].continuation.node = node;
+    backTrackStack[backTrackStackTop].state = copyState(x);
+    return &backTrackStack[backTrackStackTop++];
+}
+
+
+
+
+REbool parseDisjunction(REParseState *parseState);
+REbool parseAlternative(REParseState *parseState);
+REbool parseTerm(REParseState *parseState);
+
+/*
+1. If IgnoreCase is false, return ch.
+2. Let u be ch converted to upper case as if by calling 
+   String.prototype.toUpperCase on the one-character string ch.
+3. If u does not consist of a single character, return ch.
+4. Let cu be u's character.
+5. If ch's code point value is greater than or equal to decimal 128 and cu's
+   code point value is less than decimal 128, then return ch.
+6. Return cu.
+*/
+
+#define TOUPPER(c) (c & ~0x20)
+
+REchar canonicalize(REchar ch)
+{
+    return TOUPPER(ch); 
+}
+
+REbool isASCIIHexDigit(REchar c, REuint32 *digit)
+{
+    REuint32 cv = c;
+
+    if (cv < '0')
+        return false;
+    if (cv <= '9') {
+        *digit = cv - '0';
+        return true;
+    }
+    cv |= 0x20;
+    if (cv >= 'a' && cv <= 'f') {
+        *digit = cv - 'a' + 10;
+        return true;
+    }
+    return false;
+}
+
+
+/*
+    Allocate & initialize a new node.
+*/
+RENode *newRENode(REParseState *parseState, REOp kind)
+{
+    RENode *result = (RENode *)malloc(sizeof(RENode));
+    if (result == NULL) {
+        reportRegExpError(&parseState->error, OUT_OF_MEMORY);
+        return NULL;
+    }
+    if ((parseState->flags & IGNORECASE) && (kind == REOP_FLAT1))
+	result->kind = REOP_FLAT1i;
+    else
+	result->kind = kind;
+    result->next = NULL;
+    result->child = NULL;
+    return result;
+}
+
+REbool parseDisjunction(REParseState *parseState)
+{
+    if (!parseAlternative(parseState)) return false;
+    
+    if ((parseState->src != parseState->srcEnd) && (*parseState->src == '|')) {
+        RENode *altResult;
+        ++parseState->src;
+        altResult = newRENode(parseState, REOP_ALT);
+        if (!altResult) return false;
+        altResult->child = parseState->result;
+        if (!parseDisjunction(parseState)) return false;
+        altResult->data.child2 = parseState->result;
+        parseState->result = altResult;
+    }
+    return true;
+}
+
+/*
+ *   Return a single REOP_Empty node for an empty Alternative, 
+ *   a single REOP_xxx node for a single term and a next field 
+ *   linked list for a list of terms for more than one term. 
+ *   Consecutive FLAT1 nodes get combined into a single FLATN
+ */
+REbool parseAlternative(REParseState *parseState)
+{
+    RENode *headTerm = NULL;
+    RENode *tailTerm = NULL;
+    while (true) {
+        if ((parseState->src == parseState->srcEnd)
+                || (*parseState->src == ')')
+                || (*parseState->src == '|')) {
+            if (!headTerm) {
+                parseState->result = newRENode(parseState, REOP_EMPTY);
+                if (!parseState->result) return false;
+            }
+            else
+                parseState->result = headTerm;
+            return true;
+        }
+        if (!parseTerm(parseState)) return false;
+        if (headTerm == NULL)
+            headTerm = parseState->result;
+        else {
+            if (tailTerm == NULL) {
+                if ((headTerm->kind == REOP_FLAT1) 
+                        && headTerm->child 
+                        && (parseState->result->kind == REOP_FLAT1)
+                        && (parseState->result->child 
+                                    == (REchar *)(headTerm->child) + 1) ) {
+                    headTerm->kind = REOP_FLATN;
+                    headTerm->data.length = 2;
+                    free(parseState->result);
+                }
+                else {
+		    if ((headTerm->kind == REOP_FLAT1i) 
+			    && headTerm->child 
+			    && (parseState->result->kind == REOP_FLAT1i)
+			    && (parseState->result->child 
+					== (REchar *)(headTerm->child) + 1) ) {
+			headTerm->kind = REOP_FLATNi;
+			headTerm->data.length = 2;
+			free(parseState->result);
+		    }
+		    else {
+			headTerm->next = parseState->result;
+			tailTerm = parseState->result;
+		    }
+		}
+            }
+            else {
+                if ((headTerm->kind == REOP_FLATN) 
+                        && headTerm->child 
+                        && (parseState->result->kind == REOP_FLAT1)
+                        && ((REchar *)(parseState->result->child) 
+                                    == (REchar *)(headTerm->child) 
+                                                + headTerm->data.length) ) {
+                    headTerm->data.length++;
+                    free(parseState->result);
+                }
+		else {
+		    if ((headTerm->kind == REOP_FLATNi) 
+			    && headTerm->child 
+			    && (parseState->result->kind == REOP_FLAT1i)
+			    && ((REchar *)(parseState->result->child) 
+					== (REchar *)(headTerm->child) 
+						    + headTerm->data.length) ) {
+			headTerm->data.length++;
+			free(parseState->result);
+		    }
+		    else {
+			tailTerm->next = parseState->result;
+			tailTerm = tailTerm->next;
+		    }
+		}
+            }
+        }
+    }
+}
+
+REuint32 getDecimalValue(REchar c, REParseState *parseState)
+{
+    REuint32 value = RE_UNDEC(c);
+    c = *parseState->src; 
+    while (RE_ISDEC(c) && (parseState->src < parseState->srcEnd)) { 
+        value = (10 * value) + RE_UNDEC(c); 
+        c = *++parseState->src;
+    }
+    return value;
+}
+
+REbool parseTerm(REParseState *parseState)
+{
+    REchar c = *parseState->src++;
+    REuint32 nDigits;
+    REuint32 parenBaseCount = parseState->parenCount;
+    REuint32 num, tmp;
+    RENode *term;
+
+    switch (c) {
+    /* assertions and atoms */
+    case '^':
+        parseState->result = newRENode(parseState, REOP_BOL);
+        if (!parseState->result) return false;
+        break;
+    case '$':
+        parseState->result = newRENode(parseState, REOP_EOL);
+        if (!parseState->result) return false;
+        break;
+    case '\\':
+        if (parseState->src < parseState->srcEnd) {
+            c = *parseState->src++;
+            switch (c) {
+            /* assertion escapes */
+            case 'B' :
+                parseState->result = newRENode(parseState, REOP_WBND);
+                if (!parseState->result) return false;
+                break;
+            case 'b':
+                parseState->result = newRENode(parseState, REOP_UNWBND);
+                if (parseState->result) return false;
+                break;
+            /* Decimal escape */
+            case '0':
+                if (parseState->oldSyntax) {
+                    /* octal escape (supported for backward compatibility) */
+                    num = 0;
+                    while ((parseState->src < parseState->srcEnd) 
+                                && ('0' <= (c = *parseState->src++))
+                                && (c <= '7')) {
+                        tmp = 8 * num + (REuint32)RE_UNDEC(c);
+                        if (tmp > 0377)
+                            break;
+                        num = tmp;
+                    }
+                    parseState->src--;
+                    parseState->result = newRENode(parseState, REOP_FLAT1);
+                    if (!parseState->result) return false;
+                    parseState->result->data.ch = num;
+                }
+                else {
+                    parseState->result = newRENode(parseState, REOP_FLAT1);
+                    if (!parseState->result) return false;
+                    parseState->result->data.ch = 0;
+                    parseState->result->child = (void *)(parseState->src - 1);
+                }
+                break;
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                parseState->result = newRENode(parseState, REOP_BACKREF);
+                if (!parseState->result) return false;
+                parseState->result->parenIndex
+                                        = getDecimalValue(c, parseState) - 1;
+                break;
+            /* Control escape */
+            case 'f':
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                parseState->result->data.ch = 0xC;
+                break;
+            case 'n':
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                parseState->result->data.ch = 0xA;
+                break;
+            case 'r':
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                parseState->result->data.ch = 0xD;
+                break;
+            case 't':
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                parseState->result->data.ch = 0x9;
+                break;
+            case 'v':
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                parseState->result->data.ch = 0xB;
+                break;
+            /* Control letter */
+            case 'c':
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                if (((parseState->src + 1) < parseState->srcEnd) &&
+                                    RE_ISLETTER(parseState->src[1]))
+                    parseState->result->data.ch = *parseState->src++ & 0x1F;
+                else {
+                    /* back off to accepting the original '\' as a literal */
+                    --parseState->src;
+                    parseState->result->data.ch = '\\';
+                    parseState->result->child = (void *)parseState->src;
+                }
+                break;
+            /* HexEscapeSequence */
+            case 'x':
+                nDigits = 2;
+                goto lexHex;
+            /* UnicodeEscapeSequence */
+            case 'u':
+                nDigits = 4;
+lexHex:
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                {
+                    REuint32 n = 0;
+                    REuint32 i;
+                    for (i = 0; (i < nDigits) 
+                            && (parseState->src < parseState->srcEnd); i++) {
+                        REuint32 digit;
+                        c = *parseState->src++;
+                        if (!isASCIIHexDigit(c, &digit)) {
+                            /* back off to accepting the original 
+                             *'u' or 'x' as a literal 
+                             */
+                            parseState->src -= (i + 2);
+                            n = *parseState->src++;
+                            break;
+                        }
+                        n = (n << 4) | digit;
+                    }
+                    parseState->result->data.ch = n;
+                }
+                break;
+            /* Character class escapes */
+            case 'd':
+                parseState->result = newRENode(parseState, REOP_DEC);
+                if (!parseState->result) return false;
+                break;
+            case 'D':
+                parseState->result = newRENode(parseState, REOP_UNDEC);
+                if (!parseState->result) return false;
+                break;
+            case 's':
+                parseState->result = newRENode(parseState, REOP_WS);
+                if (!parseState->result) return false;
+                break;
+            case 'S':
+                parseState->result = newRENode(parseState, REOP_UNWS);
+                if (!parseState->result) return false;
+                break;
+            case 'w':
+                parseState->result = newRENode(parseState, REOP_LETDIG);
+                if (!parseState->result) return false;
+                break;
+            case 'W':
+                parseState->result = newRENode(parseState, REOP_UNLETDIG);
+                if (!parseState->result) return false;
+                break;
+            /* IdentityEscape */
+            default:
+                parseState->result = newRENode(parseState, REOP_FLAT1);
+                if (!parseState->result) return false;
+                parseState->result->data.ch = c;
+                parseState->result->child = (void *)(parseState->src - 1);
+                break;
+            }
+            break;
+        }
+        else {
+            /* a trailing '\' is an error */
+            reportRegExpError(&parseState->error, TRAILING_SLASH);
+            return false;
+        }
+    case '(':
+        {
+            RENode *result = NULL;
+            if ((*parseState->src == '?') 
+                    && ( (parseState->src[1] == '=')
+                            || (parseState->src[1] == '!')
+                            || (parseState->src[1] == ':') )) {
+                ++parseState->src;
+                switch (*parseState->src++) {
+                case '=':
+                    result = newRENode(parseState, REOP_ASSERT);
+                    if (!result) return false;
+                    break;
+                case '!':
+                    result = newRENode(parseState, REOP_ASSERTNOT);
+                    if (!result) return false;
+                    break;
+                }
+            }
+            else {
+                result = newRENode(parseState, REOP_PAREN);
+                if (!result) return false;
+                result->parenIndex = parseState->parenCount++;
+            }
+            if (!parseDisjunction(parseState)) return false;
+            if ((parseState->src == parseState->srcEnd)
+                    || (*parseState->src != ')')) {
+                reportRegExpError(&parseState->error, UNCLOSED_PAREN);
+                return false;
+            }
+            else {
+                ++parseState->src;
+            }
+            if (result) {
+                result->child = parseState->result;
+                parseState->result = result;
+            }
+            break;
+        }
+    case '[':
+        parseState->result = newRENode(parseState, REOP_CLASS);
+        if (!parseState->result) return false;
+        parseState->result->child = (void *)(parseState->src);
+        parseState->result->data.chclass.charSet = NULL;
+        while (true) {
+            if (parseState->src == parseState->srcEnd) {
+                reportRegExpError(&parseState->error, UNCLOSED_CLASS);
+                return false;
+            }
+            if (*parseState->src == '\\') {
+                ++parseState->src;
+                if (RE_ISDEC(*parseState->src)) {
+                    reportRegExpError(&parseState->error, BACKREF_IN_CLASS);
+                    return false;
+                }
+            }
+            else {
+                if (*parseState->src == ']') {
+                    parseState->result->data.chclass.end = parseState->src++;
+                    break;
+                }
+            }
+            ++parseState->src;
+        }
+        break;
+
+    case '.':
+        parseState->result = newRENode(parseState, REOP_DOT);
+        if (!parseState->result) return false;
+        break;
+    default:
+        parseState->result = newRENode(parseState, REOP_FLAT1);
+        if (!parseState->result) return false;
+        parseState->result->data.ch = c;
+        parseState->result->child = (void *)(parseState->src - 1);
+        break;
+    }
+
+    term = parseState->result;
+    if (parseState->src < parseState->srcEnd) {
+        switch (*parseState->src) {
+        case '+':
+            parseState->result = newRENode(parseState, REOP_QUANT);
+            if (!parseState->result) return false;
+            parseState->result->data.quantifier.min = 1;
+            parseState->result->data.quantifier.max = -1;
+            goto quantifier;
+        case '*':
+            parseState->result = newRENode(parseState, REOP_QUANT);
+            if (!parseState->result) return false;
+            parseState->result->data.quantifier.min = 0;
+            parseState->result->data.quantifier.max = -1;
+            goto quantifier;
+        case '?':
+            parseState->result = newRENode(parseState, REOP_QUANT);
+            if (!parseState->result) return false;
+            parseState->result->data.quantifier.min = 0;
+            parseState->result->data.quantifier.max = 1;
+            goto quantifier;
+        case '{':
+            {
+                REint32 min = 0;
+                REint32 max = -1;
+                REchar c;
+                ++parseState->src;
+            
+                parseState->result = newRENode(parseState, REOP_QUANT);
+                if (!parseState->result) return false;
+
+                c = *parseState->src;
+                if (RE_ISDEC(c)) {
+                    ++parseState->src;
+                    min = getDecimalValue(c, parseState);
+                    c = *parseState->src;
+                }
+                if (c == ',') {
+                    c = *++parseState->src;
+                    if (RE_ISDEC(c)) {
+                        ++parseState->src;
+                        max = getDecimalValue(c, parseState);
+                        c = *parseState->src;
+                    }
+                }
+                parseState->result->data.quantifier.min = min;
+                parseState->result->data.quantifier.max = max;
+                if (c == '}')
+                    goto quantifier;
+                else {
+                    reportRegExpError(&parseState->error, UNCLOSED_BRACKET);
+                    return false;
+                }
+            }
+        }
+    }
+    return true;
+
+quantifier:
+    ++parseState->src;
+    parseState->result->child = term;
+    parseState->result->parenIndex = parenBaseCount;
+    parseState->result->data.quantifier.parenCount 
+                                = parseState->parenCount - parenBaseCount;
+    if ((parseState->src < parseState->srcEnd) && (*parseState->src == '?')) {
+        ++parseState->src;
+        parseState->result->data.quantifier.greedy = false;
+    }
+    else
+        parseState->result->data.quantifier.greedy = true;  
+    return true;
+}
+
+
+
+
+
+
+
+
+
+
+/*
+1. Let e be x's endIndex.
+2. If e is zero, return true.
+3. If Multiline is false, return false.
+4. If the character Input[e-1] is one of the line terminator characters <LF>,
+   <CR>, <LS>, or <PS>, return true.
+5. Return false.
+*/
+REState *bolMatcher(REGlobalData *globalData, REState *x)
+{
+    REuint32 e = x->endIndex;
+    if (e != 0) {
+        if (globalData->flags & MULTILINE) {
+            if (!RE_ISLINETERM(globalData->input[e - 1]))
+                return NULL;
+        }
+        else
+            return NULL;
+    }
+    return x;
+}
+
+/*
+1. Let e be x's endIndex.
+2. If e is equal to InputLength, return true.
+3. If multiline is false, return false.
+4. If the character Input[e] is one of the line terminator characters <LF>, 
+   <CR>, <LS>, or <PS>, return true.
+5. Return false.
+*/
+REState *eolMatcher(REGlobalData *globalData, REState *x)
+{
+    REuint32 e = x->endIndex;
+    if (e != globalData->length) {
+        if (globalData->flags & MULTILINE) {
+            if (!RE_ISLINETERM(globalData->input[e]))
+                return NULL;
+        }
+        else
+            return NULL;
+    }
+    return x;
+}
+
+/*
+1. If e == -1 or e == InputLength, return false.
+2. Let c be the character Input[e].
+3. If c is one of the sixty-three characters in the table below, return true.
+a b c d e f g h i j k l m n o p q r s t u v w x y z
+A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+0 1 2 3 4 5 6 7 8 9 _
+4. Return false.
+*/
+REbool isWordChar(REint32 e, REGlobalData *globalData)
+{
+    REchar c;
+    if ((e == -1) || (e == (REint32)(globalData->length)))
+        return false;
+    c = globalData->input[e];
+    if (RE_ISLETDIG(c) || (c == '_'))
+        return true;
+    return false;
+}
+
+/*
+1. Let e be x's endIndex.
+2. Call IsWordChar(e-1) and let a be the boolean result.
+3. Call IsWordChar(e) and let b be the boolean result.
+for '\b'
+4. If a is true and b is false, return true.
+5. If a is false and b is true, return true.
+6. Return false.
+
+for '\B'
+4. If a is true and b is false, return false.
+5. If a is false and b is true, return false.
+6. Return true.
+*/
+REState *wbndMatcher(REGlobalData *globalData, REState *x, REbool sense)
+{
+    REint32 e = (REint32)(x->endIndex);
+
+    REbool a = isWordChar(e - 1, globalData);
+    REbool b = isWordChar(e, globalData);
+    
+    if (sense) {
+        if ((a && !b) || (!a && b))
+            return x;
+        else
+            return NULL;
+    }
+    else {
+        if ((a && !b) || (!a && b))
+            return NULL;
+        else
+            return x;
+    }
+}
+
+/*
+1. Let A be the set of all characters except the four line terminator 
+   characters <LF>, <CR>, <LS>, or <PS>.
+2. Call CharacterSetMatcher(A, false) and return its Matcher result.
+*/
+REState *dotMatcher(REGlobalData *globalData, REState *x)
+{
+    REchar ch;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    ch = globalData->input[e];
+    if (RE_ISLINETERM(ch))
+        return NULL;
+    x->endIndex++;
+    return x;
+}
+
+/*
+    \d evaluates by returning the ten-element set of characters containing the
+    characters 0 through 9 inclusive.
+    \D evaluates by returning the set of all characters not included in the set
+    returned by \d.
+*/
+REState *decMatcher(REGlobalData *globalData, REState *x, REbool sense)
+{
+    REchar ch;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    ch = globalData->input[e];
+    if (RE_ISDEC(ch) != sense)
+        return NULL;
+    x->endIndex++;
+    return x;
+}
+
+/*
+    \s evaluates by returning the set of characters containing
+    the characters that are on the right-hand side of the WhiteSpace 
+    (section 7.2) or LineTerminator (section 7.3) productions.
+    \S evaluates by returning the set of all characters not 
+    included in the set returned by \s.
+*/
+REState *wsMatcher(REGlobalData *globalData, REState *x, REbool sense)
+{
+    REchar ch;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    ch = globalData->input[e];
+    if (RE_ISWS(ch) != sense)
+        return NULL;
+    x->endIndex++;
+    return x;
+}
+
+/*
+    \w evaluates by returning the set of characters containing the sixty-three
+    characters:
+    a b c d e f g h i j k l m n o p q r s t u v w x y z
+    A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
+    0 1 2 3 4 5 6 7 8 9 _
+    \W evaluates by returning the set of all characters not included in the set
+    returned by \w.
+*/
+REState *letdigMatcher(REGlobalData *globalData, REState *x, REbool sense)
+{
+    REchar ch;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    ch = globalData->input[e];
+    if (RE_ISLETDIG(ch) != sense)
+        return NULL;
+    x->endIndex++;
+    return x;
+}
+
+/*
+1. Return an internal Matcher closure that takes two arguments, a State x 
+and a Continuation c, and performs the following:
+    1. Let e be x's endIndex.
+    2. If e == InputLength, return failure.
+    3. Let c be the character Input[e].
+    4. Let cc be the result of Canonicalize(c).
+    5. If invert is true, go to step 8.
+    6. If there does not exist a member a of set A such that Canonicalize(a) 
+       == cc, then return failure.
+    7. Go to step 9.
+    8. If there exists a member a of set A such that Canonicalize(a) == cc,
+       then return failure.
+    9. Let cap be x's captures internal array.
+    10. Let y be the State (e+1, cap).
+    11. Call c(y) and return its result.
+*/
+REState *flatMatcher(REGlobalData *globalData, REState *x, REchar matchCh)
+{
+    REchar ch;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    ch = globalData->input[e];
+
+    if (ch != matchCh)
+        return NULL;
+    x->endIndex++;
+    return x;
+}
+
+REState *flatIMatcher(REGlobalData *globalData, REState *x, REchar matchCh)
+{
+    REchar ch;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    ch = globalData->input[e];
+
+    if (canonicalize(ch) != canonicalize(matchCh))
+        return NULL;
+    x->endIndex++;
+    return x;
+}
+
+/*
+    Consecutive literal characters.
+*/
+REState *flatNMatcher(REGlobalData *globalData, REState *x, REchar *matchChars,
+                      REuint32 length)
+{
+    REuint32 e = x->endIndex;
+    REuint32 i;
+
+    if ((e + length) > globalData->length)
+        return NULL;
+    
+    for (i = 0; i < length; i++) {
+        if (matchChars[i] != globalData->input[e + i])
+            return NULL;
+    }
+    x->endIndex += length;
+    return x;
+}
+
+REState *flatNIMatcher(REGlobalData *globalData, REState *x, REchar *matchChars,
+                      REuint32 length)
+{
+    REuint32 e = x->endIndex;
+    REuint32 i;
+
+    if ((e + length) > globalData->length)
+        return NULL;
+    
+    for (i = 0; i < length; i++) {
+        if (canonicalize(matchChars[i]) 
+                != canonicalize(globalData->input[e + i]))
+            return NULL;
+    }
+    x->endIndex += length;
+    return x;
+}
+
+/* Add a single character to the CharSet */
+void addCharacterToCharSet(CharSet *cs, REchar c)
+{
+    REuint32 byteIndex = (c / 8);
+    ASSERT(c < cs->length);
+    cs->bits[byteIndex] |= 1 << (c & 0x7);
+}
+
+/* Add a character range, c1 to c2 (inclusive) to the CharSet */
+void addCharacterRangeToCharSet(CharSet *cs, REchar c1, REchar c2)
+{
+    REuint32 i;
+
+    REuint32 byteIndex1 = (c1 / 8);
+    REuint32 byteIndex2 = (c2 / 8);
+
+    ASSERT((c2 <= cs->length) && (c1 <= c2));
+
+    cs->bits[byteIndex1] |= 0xFF << (c1 & 0x7);
+    for (i = byteIndex1 + 1; i < byteIndex2; i++)
+        cs->bits[i] = 0xFF;
+    cs->bits[byteIndex2] |= (uint8)(0xFF) >> (7 - (c2 & 0x7));
+}
+
+/* calculate the total size of the bitmap required for a class expression */
+REbool calculateBitmapSize(RENode *target)
+{
+    const REchar *rangeStart;
+    const REchar *src = (const REchar *)(target->child);
+    const REchar *end = target->data.chclass.end;
+
+    REchar c;
+    REuint32 nDigits;
+    REuint32 i;
+    REuint32 max = 0;
+
+    CharSet *charSet = (CharSet *)malloc(sizeof(CharSet));
+    if (!charSet) return false;
+    target->data.chclass.charSet = charSet;
+    charSet->length = 0;
+
+    if (src == end)
+        return true;
+
+    if (*src == '^')
+        ++src;
+    
+    while (src != end) {
+        REuint32 localMax = 0;
+        switch (*src) {
+        case '\\':
+            ++src;
+            c = *src++;
+            switch (c) {
+            case 'b':
+                localMax = 0x8;
+                break;
+            case 'f':
+                localMax = 0xC;
+                break;
+            case 'n':
+                localMax = 0xA;
+                break;
+            case 'r':
+                localMax = 0xD;
+                break;
+            case 't':
+                localMax = 0x9;
+                break;
+            case 'v':
+                localMax = 0xB;
+                break;
+            case 'c':
+                if (((src + 1) < end) && RE_ISLETTER(src[1]))
+                    localMax = *src++ & 0x1F;
+                else
+                    localMax = '\\';
+                break;
+            case 'x':
+                nDigits = 2;
+                goto lexHex;
+            case 'u':
+                nDigits = 4;
+lexHex:
+                {
+                    REuint32 n = 0;
+                    for (i = 0; (i < nDigits) && (src < end); i++) {
+                        REuint32 digit;
+                        c = *src++;
+                        if (!isASCIIHexDigit(c, &digit)) {
+                            /* back off to accepting the original 
+                             *'\' as a literal 
+                             */
+                            src -= (i + 1);
+                            n = '\\';
+                            break;
+                        }
+                        n = (n << 4) | digit;
+                    }
+                    localMax = n;
+                }
+                break;
+            case 'd':
+                localMax = '9';
+                break;
+            case 'D':
+            case 's':
+            case 'S':
+            case 'w':
+            case 'W':
+                charSet->length = 65536;
+                return true;
+            default:
+                localMax = c;
+                break;
+            }
+            break;
+        default:
+            rangeStart = src++;
+            if ((src < (end - 1)) && (*src == '-')) {
+                ++src;
+                localMax = *src++;
+            }
+            else
+                localMax = *rangeStart;
+            break;
+        }
+        if (localMax > max)
+            max = localMax;
+    }
+    charSet->length = max + 1;
+    return true;
+}
+
+/* Compile the source of the class into a CharSet */
+REbool processCharSet(RENode *target)
+{
+    const REchar *rangeStart;
+    const REchar *src = (const REchar *)(target->child);
+    const REchar *end = target->data.chclass.end;
+
+    REchar c;
+    REint32 nDigits;
+    REint32 i;
+    CharSet *charSet;
+
+    if (!calculateBitmapSize(target))
+        return false;
+    charSet = target->data.chclass.charSet;
+    i = (charSet->length / 8) + 1;
+    charSet->bits = (uint8 *)malloc(i);
+    if (!charSet->bits)
+        return false;
+    memset(charSet->bits, 0, i);
+
+    target->data.chclass.sense = true;
+
+    if (src == end)
+        return true;
+
+    if (*src == '^') {
+        target->data.chclass.sense = false;
+        ++src;
+    }
+    while (src != end) {
+        switch (*src) {
+        case '\\':
+            ++src;
+            c = *src++;
+            switch (c) {
+            case 'b':
+                addCharacterToCharSet(charSet, 0x8);
+                break;
+            case 'f':
+                addCharacterToCharSet(charSet, 0xC);
+                break;
+            case 'n':
+                addCharacterToCharSet(charSet, 0xA);
+                break;
+            case 'r':
+                addCharacterToCharSet(charSet, 0xD);
+                break;
+            case 't':
+                addCharacterToCharSet(charSet, 0x9);
+                break;
+            case 'v':
+                addCharacterToCharSet(charSet, 0xB);
+                break;
+            case 'c':
+                if (((src + 1) < end) && RE_ISLETTER(src[1]))
+                    addCharacterToCharSet(charSet, (REchar)(*src++ & 0x1F));
+                else {
+                    --src;
+                    addCharacterToCharSet(charSet, '\\');
+                }
+                break;
+            case 'x':
+                nDigits = 2;
+                goto lexHex;
+            case 'u':
+                nDigits = 4;
+lexHex:
+                {
+                    REuint32 n = 0;
+                    for (i = 0; (i < nDigits) && (src < end); i++) {
+                        REuint32 digit;
+                        c = *src++;
+                        if (!isASCIIHexDigit(c, &digit)) {
+                            /* back off to accepting the original '\' 
+                             * as a literal
+                             */
+                            src -= (i + 1);
+                            n = '\\';
+                            break;
+                        }
+                        n = (n << 4) | digit;
+                    }
+                    addCharacterToCharSet(charSet, (REchar)(n));
+                }
+                break;
+            case 'd':
+                addCharacterRangeToCharSet(charSet, '0', '9');
+                break;
+            case 'D':
+                addCharacterRangeToCharSet(charSet, 0, '0' - 1);
+                addCharacterRangeToCharSet(charSet, (REchar)('9' + 1),
+                                            (REchar)(charSet->length));
+                break;
+            case 's':
+                for (i = charSet->length; i >= 0; i--)
+                    if (RE_ISWS(i))
+                        addCharacterToCharSet(charSet, (REchar)(i));
+                break;
+            case 'S':
+                for (i = charSet->length; i >= 0; i--)
+                    if (!RE_ISWS(i))
+                        addCharacterToCharSet(charSet, (REchar)(i));
+                break;
+            case 'w':
+                for (i = charSet->length; i >= 0; i--)
+                    if (RE_ISLETDIG(i))
+                        addCharacterToCharSet(charSet, (REchar)(i));
+                break;
+            case 'W':
+                for (i = charSet->length; i >= 0; i--)
+                    if (!RE_ISLETDIG(i))
+                        addCharacterToCharSet(charSet, (REchar)(i));
+                break;
+            default:
+                addCharacterToCharSet(charSet, c);
+                break;
+            }
+            break;
+        default:
+            rangeStart = src++;
+            if ((src < (end - 1)) && (*src == '-')) {
+                ++src;
+                addCharacterRangeToCharSet(charSet, *rangeStart, *src++);
+            }
+            else
+                addCharacterToCharSet(charSet, *rangeStart);
+            break;
+        }
+    }
+    return true;
+}
+
+/*
+    Initialize the character set if it this is the first call.
+    Test the bit - if the ^ flag was specified, non-inclusion is a success
+*/
+REState *classMatcher(REGlobalData *globalData, REState *x, RENode *target)
+{
+    REchar ch;
+    CharSet *charSet;
+    REuint32 byteIndex;
+    REuint32 e = x->endIndex;
+    if (e == globalData->length)
+        return NULL;
+    if (target->data.chclass.charSet == NULL) {
+        if (!processCharSet(target))
+            return NULL;
+    }
+    charSet = target->data.chclass.charSet;
+    ch = globalData->input[e];
+    byteIndex = (ch / 8) + 1;
+    if (target->data.chclass.sense) {
+        if ( (ch > charSet->length)
+                || ((charSet->bits[byteIndex - 1] & (1 << (ch & 0x7))) == 0) )
+            return NULL;
+    }
+    else {
+        if (! ( (ch > charSet->length)
+                || ((charSet->bits[byteIndex - 1] & (1 << (ch & 0x7))) == 0)) )
+            return NULL;
+    }
+    x->endIndex++;
+    return x;
+}
+
+
+
+
+
+/*
+1. Evaluate DecimalEscape to obtain an EscapeValue E.
+2. If E is not a character then go to step 6.
+3. Let ch be E's character.
+4. Let A be a one-element CharSet containing the character ch.
+5. Call CharacterSetMatcher(A, false) and return its Matcher result.
+6. E must be an integer. Let n be that integer.
+7. If n=0 or n>NCapturingParens then throw a SyntaxError exception.
+8. Return an internal Matcher closure that takes two arguments, a State x 
+   and a Continuation c, and performs the following:
+    1. Let cap be x's captures internal array.
+    2. Let s be cap[n].
+    3. If s is undefined, then call c(x) and return its result.
+    4. Let e be x's endIndex.
+    5. Let len be s's length.
+    6. Let f be e+len.
+    7. If f>InputLength, return failure.
+    8. If there exists an integer i between 0 (inclusive) and len (exclusive)
+       such that Canonicalize(s[i]) is not the same character as 
+       Canonicalize(Input [e+i]), then return failure.
+    9. Let y be the State (f, cap).
+    10. Call c(y) and return its result.
+*/
+
+REState *backrefMatcher(REGlobalData *globalData, REState *x, RENode *child)
+{
+    REuint32 e;
+    REuint32 len;
+    REuint32 f;
+    REuint32 i;
+    const REchar *parenContent;
+    RECapture *s = &x->parens[child->parenIndex];
+    if (s->index == -1)
+        return x;
+
+    e = x->endIndex;
+    len = s->length;
+    f = e + len;
+    if (f > globalData->length)
+        return NULL;
+    
+    parenContent = &globalData->input[s->index];
+    if (globalData->flags & IGNORECASE) {
+        for (i = 0; i < len; i++) {
+            if (canonicalize(parenContent[i]) 
+                            != canonicalize(globalData->input[e + i]))
+                return NULL;
+        }
+    }
+    else {
+        for (i = 0; i < len; i++) {
+            if (parenContent[i] != globalData->input[e + i])
+                return NULL;
+        }
+    }
+    x->endIndex = f;
+    return x;
+}
+
+/*
+    free memory the RENode t and it's children, plus any attached memory
+*/
+void freeRENode(RENode *t)
+{
+    RENode *n;
+    while (t) {
+        switch (t->kind) {
+        case REOP_ALT:  
+            freeRENode((RENode *)(t->child));
+            freeRENode((RENode *)(t->data.child2));
+            break;
+        case REOP_QUANT:
+            freeRENode((RENode *)(t->child));
+            break;
+        case REOP_PAREN:
+            freeRENode((RENode *)(t->child));
+            break;
+        case REOP_ASSERT:
+            freeRENode((RENode *)(t->child));
+            break;
+        case REOP_ASSERTNOT:
+            freeRENode((RENode *)(t->child));
+            break;
+        case REOP_CLASS:
+            if (t->data.chclass.charSet)
+                free(t->data.chclass.charSet);
+            break;
+        }
+        n = t->next;
+        free(t);
+        t = n;
+    }
+}
+
+/*
+ *  Throw away the RegExp and all data associated with it.
+ */
+void freeRegExp(REParseState *pState)
+{
+    freeRENode(pState->result);
+    free(pState);
+}
+
+/*
+ *  Iterate over the linked RENodes, attempting a match at each. When the
+ *  end of list is reached, the 'currentContinuation' specifies the next
+ *  node and op (which may be different from that in the node).
+ *  The backTrackStack maintains a stack of so-far succesful states. When
+ *  a match fails the state on the top of the stack is re-instated.
+ *
+ */
+REState *executeRENode(RENode *t, REGlobalData *globalData, REState *x)
+{
+    REOp op = t->kind;
+    REContinuationData currentContinuation;
+    REState *result;
+    REBackTrackData *backTrackData;
+    REuint32 k;
+
+    currentContinuation.node = NULL;
+
+    while (true) {      /* loop over next links & current continuation */
+        switch (op) {
+        case REOP_EMPTY:
+            result = x;
+            break;
+        case REOP_BOL:
+            result = bolMatcher(globalData, x);
+            break;
+        case REOP_EOL:
+            result = eolMatcher(globalData, x);
+            break;
+        case REOP_WBND:
+            result = wbndMatcher(globalData, x, true);
+            break;
+        case REOP_UNWBND:
+            result = wbndMatcher(globalData, x, false);
+            break;
+        case REOP_DOT:
+            result = dotMatcher(globalData, x);
+            break;
+        case REOP_DEC:
+            result = decMatcher(globalData, x, true);
+            break;
+        case REOP_UNDEC:
+            result = decMatcher(globalData, x, false);
+            break;
+        case REOP_WS:
+            result = wsMatcher(globalData, x, true);
+            break;
+        case REOP_UNWS:
+            result = wsMatcher(globalData, x, false);
+            break;
+        case REOP_LETDIG:
+            result = letdigMatcher(globalData, x, true);
+            break;
+        case REOP_UNLETDIG:
+            result = letdigMatcher(globalData, x, false);
+            break;
+        case REOP_FLAT1:
+            result = flatMatcher(globalData, x, t->data.ch);
+            break;
+        case REOP_FLATN:
+            result = flatNMatcher(globalData, x, (REchar *)(t->child),
+                                                            t->data.length);
+            break;
+        case REOP_FLAT1i:
+            result = flatIMatcher(globalData, x, t->data.ch);
+            break;
+        case REOP_FLATNi:
+            result = flatNIMatcher(globalData, x, (REchar *)(t->child),
+                                                            t->data.length);
+            break;
+
+/* keep the current continuation and provide the alternate path 
+ * as a back track opportunity 
+ */
+        case REOP_ALT:  
+            t->continuation = currentContinuation;
+            currentContinuation.node = t;
+            currentContinuation.op = REOP_NEXTALT;
+            if (!pushBackTrack(globalData, REOP_NEXTALT, t, x)) return NULL;
+            t = (RENode *)(t->child);
+            ASSERT(t);
+            op = t->kind;
+            continue;
+        case REOP_NEXTALT:
+            if (result == NULL) {
+                currentContinuation.node = t;
+                currentContinuation.op = REOP_NEXTALT;
+                t = (RENode *)(t->data.child2);
+                ASSERT(t);
+                op = t->kind;
+                continue;
+            }
+            else {
+                result = x;
+                currentContinuation = t->continuation;
+                break;
+            }                
+            
+/* the child will evntually terminate, so provide a capturing state 
+ * as the continuation 
+ */
+        case REOP_PAREN:
+            t->continuation = currentContinuation;
+            currentContinuation.op = REOP_CLOSEPAREN;
+            currentContinuation.node = t;
+            x->parens[t->parenIndex].index = x->endIndex;
+            x->parens[t->parenIndex].length = 0;
+            t = (RENode *)(t->child);
+            ASSERT(t);
+            op = t->kind;
+            continue;
+        case REOP_CLOSEPAREN:
+            x->parens[t->parenIndex].length = x->endIndex 
+                                            - x->parens[t->parenIndex].index;
+            currentContinuation = t->continuation;
+            break;
+
+/* set the continuation to be a repetition of the child */
+/* that is also the back-track state in case of failure */
+        case REOP_QUANT:
+            t->continuation = currentContinuation;
+            if (t->data.quantifier.greedy) {
+                backTrackData = pushBackTrack(globalData, REOP_REPEAT, t, x);
+                if (!backTrackData) return NULL;
+                backTrackData->continuation.min = t->data.quantifier.min;
+                backTrackData->continuation.max = t->data.quantifier.max;              
+                currentContinuation.node = t;
+                currentContinuation.op = REOP_REPEAT;
+                currentContinuation.min = t->data.quantifier.min;
+                currentContinuation.max = t->data.quantifier.max;
+                currentContinuation.index = x->endIndex;
+                t = (RENode *)(t->child);
+                op = t->kind;
+                continue;
+            }
+            else {
+                if (t->data.quantifier.min > 0) {
+                    currentContinuation.node = t;
+                    currentContinuation.op = REOP_MINIMALREPEAT;
+                    currentContinuation.min = t->data.quantifier.min;
+                    currentContinuation.max = t->data.quantifier.max;
+                    currentContinuation.index = x->endIndex;
+                    t = (RENode *)(t->child);
+                    op = t->kind;
+                    continue;
+                }
+                else {
+                    backTrackData = pushBackTrack(globalData, 
+                                                    REOP_MINIMALREPEAT, t, x);
+                    if (!backTrackData) return NULL;
+                    backTrackData->continuation.min = t->data.quantifier.min;
+                    backTrackData->continuation.max = t->data.quantifier.max;
+                    result = x;
+                    break;
+                }
+            }
+
+        case REOP_REPEAT:
+            if (result == NULL) {
+                currentContinuation = t->continuation;
+                if (backTrackData->continuation.min == 0)
+                    result = x;
+                break;
+            }
+            else {
+                if ((currentContinuation.min == 0)
+                        && (x->endIndex == currentContinuation.index)) {
+                    /* matched an empty string, that'll get us nowhere */
+                    result = NULL;
+                    currentContinuation = t->continuation;
+                    break;
+                }
+                if (currentContinuation.min > 0) --currentContinuation.min;
+                if (currentContinuation.max != -1) --currentContinuation.max;
+                backTrackData = pushBackTrack(globalData, REOP_REPEAT, t, x);
+                if (!backTrackData) return NULL;
+                backTrackData->continuation.min = currentContinuation.min;
+                backTrackData->continuation.max = currentContinuation.max;
+                if (currentContinuation.max == 0) {
+                    currentContinuation = t->continuation;
+                    result = NULL;
+                    break;
+                }
+                else {                                              
+                    for (k = 1; k <= t->data.quantifier.parenCount; k++)
+                        x->parens[t->parenIndex + k].index = -1;
+                    currentContinuation.index = x->endIndex;
+                    currentContinuation.node = t;
+                    currentContinuation.op = REOP_REPEAT;
+                    t = (RENode *)(t->child);
+                    op = t->kind;
+                }
+            }
+            continue;                       
+        case REOP_MINIMALREPEAT:
+            if (result == NULL) {
+                if (backTrackData->continuation.max > 0) {
+                    for (k = 1; k <= t->data.quantifier.parenCount; k++)
+                        x->parens[t->parenIndex + k].index = -1;
+                    currentContinuation.node = t;
+                    currentContinuation.op = REOP_MINIMALREPEAT;
+                    currentContinuation.index = x->endIndex;
+                    currentContinuation.min = backTrackData->continuation.min;
+                    currentContinuation.max = backTrackData->continuation.max;
+                    t = (RENode *)(t->child);
+                    op = t->kind;
+                    continue;
+                }
+                else
+                    break;
+            }
+            else {
+                if ((currentContinuation.min == 0)
+                        && (x->endIndex == currentContinuation.index)) {
+                    /* matched an empty string, that'll get us nowhere */
+                    result = NULL;
+                    currentContinuation = t->continuation;
+                    break;
+                }
+                if (currentContinuation.min > 0) --currentContinuation.min;
+                if (currentContinuation.max != -1) --currentContinuation.max;
+                if (currentContinuation.min > 0) {
+                    for (k = 1; k <= t->data.quantifier.parenCount; k++)
+                        x->parens[t->parenIndex + k].index = -1;
+                    currentContinuation.node = t;
+                    currentContinuation.op = REOP_MINIMALREPEAT;
+                    currentContinuation.index = x->endIndex;
+                    t = (RENode *)(t->child);
+                    op = t->kind;
+                    continue;                       
+                }
+                else {
+                    backTrackData = pushBackTrack(globalData, 
+                                                    REOP_MINIMALREPEAT, t, x);
+                    if (!backTrackData) return NULL;
+                    backTrackData->continuation.min = currentContinuation.min;
+                    backTrackData->continuation.max = currentContinuation.max;
+                    currentContinuation = t->continuation;
+                    break;
+                }
+            }
+
+
+        case REOP_BACKREF:
+            result = backrefMatcher(globalData, x, t);
+            break;
+
+/* supersede the continuation with an assertion tester */
+        case REOP_ASSERT:               
+            t->continuation = currentContinuation;
+            currentContinuation.node = t;
+            currentContinuation.op = REOP_ASSERTTEST;
+            currentContinuation.index = x->endIndex;
+            currentContinuation.stackTop = backTrackStackTop;
+            t = (RENode *)(t->child);
+            ASSERT(t);  /* XXX null child expected? */
+            op = t->kind;
+            continue;
+/* also provide the assertion tester as the backtrack state */
+        case REOP_ASSERTNOT:
+            t->continuation = currentContinuation;
+            currentContinuation.node = t;
+            currentContinuation.op = REOP_ASSERTTEST;
+            currentContinuation.stackTop = backTrackStackTop;
+            if (!pushBackTrack(globalData, REOP_ASSERTTEST, t, x)) return NULL;
+            t = (RENode *)(t->child);
+            ASSERT(t);  /* XXX null child expected? */
+            op = t->kind;
+            continue;
+        case REOP_ASSERTTEST:
+            backTrackStackTop = currentContinuation.stackTop;
+            if (t->kind == REOP_ASSERT) {
+                if (result != NULL) {
+                    x->endIndex = currentContinuation.index;
+                    result = x;
+                }
+            }
+            else {
+                recoverState(x, backTrackStack[backTrackStackTop].state);
+                if (result == NULL)
+                    result = x;
+                else
+                    result = NULL;
+            }
+            currentContinuation = t->continuation;
+            break;
+
+
+
+        case REOP_CLASS:
+            result = classMatcher(globalData, x, t);
+            if (globalData->error != NO_ERROR) return NULL;
+            break;
+        case REOP_END:
+            if (x != NULL)
+                return x;
+            break;
+        }
+        /*
+         *  If the match failed and there's a backtrack option, take it.
+         *  Otherwise this is a match failure.
+         */
+        if (result == NULL) {
+            if (backTrackStackTop > 0) {
+                backTrackStackTop--;
+                backTrackData = &backTrackStack[backTrackStackTop];
+
+                recoverState(x, backTrackData->state);
+                free(backTrackData->state);
+                t = backTrackData->continuation.node;
+                op = backTrackData->continuation.op;
+                continue;
+            }
+            else
+                return NULL;
+        }
+        else
+            x = result;
+        
+        /*
+         *  Continue with the expression. If there is no next link, use
+         *  the current continuation.
+         */
+        t = t->next;
+        if (t)
+            op = t->kind;
+        else {
+            t = currentContinuation.node;
+            ASSERT(t);
+            op = currentContinuation.op;
+            currentContinuation.op = t->continuation.op;
+            currentContinuation.node = t->continuation.node;
+        }
+    }
+    return NULL;
+}
+
+/* 
+* Parse the regexp - errors are reported via the registered error function 
+* and NULL is returned. Otherwise the regexp is compiled and the completed 
+* ParseState returned.
+*/
+REParseState *REParse(const REchar *source, REuint32 sourceLength, 
+                      const REchar *flags, REuint32 flagsLength, 
+                      REbool oldSyntax)
+{
+    REuint32 i;
+    RENode *t;
+    REParseState *pState = (REParseState *)malloc(sizeof(REParseState));
+    pState->src = source;
+    pState->srcEnd = source + sourceLength;
+    pState->parenCount = 0;
+    pState->lastIndex = 0;
+    pState->flags = 0;
+    pState->oldSyntax = oldSyntax;
+
+    for (i = 0; i < flagsLength; i++) {
+        switch (flags[i]) {
+        case 'g':
+            pState->flags |= GLOBAL; break;
+        case 'i':
+            pState->flags |= IGNORECASE; break;
+        case 'm':
+            pState->flags |= MULTILINE; break;
+        default:
+            reportRegExpError(&pState->error, BAD_FLAG); 
+	    free(pState);
+	    return NULL;
+        }
+    }
+    if (parseDisjunction(pState)) {
+        t = pState->result;
+        if (t) {
+            while (t->next) t = t->next;    
+            t->next = newRENode(pState, REOP_END);
+            if (!t->next) {
+		free(pState);
+		return NULL;
+	    }
+        }
+        else
+            pState->result = newRENode(pState, REOP_END);
+        return pState;
+    }
+    else {
+	free(pState);
+        return NULL;
+    }
+}
+
+/*
+ *  Execute the RegExp against the supplied text, filling in the REState.
+ *
+ */
+REState *REExecute(REParseState *parseState, const REchar *text, 
+                   REuint32 length)
+{
+    REState *result;
+
+    REGlobalData gData;
+    REint32 i;
+    REuint32 j;
+    
+    REState *x = (REState *)malloc(sizeof(REState) 
+                        + (parseState->parenCount * sizeof(RECapture)));
+    if (!x) {
+        reportRegExpError(&gData.error, OUT_OF_MEMORY);
+        return NULL;
+    }
+
+    x->n = parseState->parenCount;
+    for (j = 0; j < x->n; j++)
+        x->parens[j].index = -1;
+
+    if (parseState->flags & GLOBAL)
+        i = parseState->lastIndex;
+    else
+        i = 0;
+
+    if ((i < 0) || (i > (REint32)length)) {
+        parseState->lastIndex = 0;
+        free(x);
+        return NULL;
+    }
+        
+    gData.flags = parseState->flags;
+    gData.input = text;
+    gData.length = length;
+    gData.error = NO_ERROR;
+
+    if (!backTrackStack) {
+        maxBackTrack = INITIAL_BACKTRACK;
+        backTrackStack = (REBackTrackData *)malloc(sizeof(REBackTrackData) 
+                                                            * maxBackTrack);
+        if (!backTrackStack) {
+            reportRegExpError(&gData.error, OUT_OF_MEMORY);
+            free(x);
+            return NULL;
+        }
+    }
+
+    /*
+	Simple anchoring optimization -
+    */
+    if ((parseState->result->kind == REOP_FLAT1) 
+	    || (parseState->result->kind == REOP_FLATN)) {
+	REchar matchCh = parseState->result->data.ch;
+        if (parseState->result->kind == REOP_FLATN)
+            matchCh = *((REchar *)parseState->result->child);
+	for (j = i; j < length; j++) {
+	    if (text[j] == matchCh) {
+		i = j;
+		break;
+	    }
+	}
+	if (j == length) {
+            parseState->lastIndex = 0;
+	    free(x);
+	    return NULL;
+	}
+    }
+
+    while (true) {
+        x->endIndex = i;
+        backTrackStackTop = 0;
+        result = executeRENode(parseState->result, &gData, x);
+	for (j = 0; j < backTrackStackTop; j++)
+	    free(backTrackStack[j].state);
+        if (gData.error != NO_ERROR) return NULL;
+        if (result == NULL) {
+            i++;
+            if (i >= (REint32)length) {
+                parseState->lastIndex = 0;
+                result = NULL;
+                free(x);
+                break;
+            }
+        }
+        else {
+            if (parseState->flags & GLOBAL)
+                parseState->lastIndex = result->endIndex;
+            result->length = result->endIndex - i;
+            result->endIndex = i;
+            break;
+        }
+    }
+    return result;
+}
+
+#ifdef STANDALONE
+
+REchar *widen(char *str, int length)
+{
+    int i;
+    REchar *result = (REchar *)malloc(sizeof(REchar) * (length + 1));
+    for (i = 0; i < length; i++)
+        result[i] = str[i];
+    return result;
+}
+
+int main(int argc, char* argv[])
+{
+    char regexpInput[128];
+    char *regexpSrc;
+    char str[128];
+    REState *result;
+    int regexpLength;
+    char *flagSrc;
+    int flagSrcLength;
+    REuint32 i, j;
+
+    printf("Delimit regexp by /  / (with flags following) and strings by \"  \"\n");
+    while (true) {
+        REchar *regexpWideSrc;
+        REchar *flagWideSrc;
+        REParseState *pState;
+
+        printf("regexp : ");
+        scanf("%s", regexpInput);
+        regexpSrc = regexpInput;
+        if (*regexpSrc != '/')
+            break;
+        regexpSrc++;
+        flagSrc = strrchr(regexpSrc, '/');
+        if (flagSrc == NULL)
+            break;
+        regexpLength = flagSrc - regexpSrc;
+        if (flagSrc[1]) {
+            flagSrc++;
+            flagSrcLength = strlen(flagSrc);
+        }
+        else {
+            flagSrc = NULL;
+            flagSrcLength = 0;
+        }
+
+        regexpWideSrc = widen(regexpSrc, regexpLength);
+        flagWideSrc = widen(flagSrc, flagSrcLength);
+        pState = REParse(regexpWideSrc, regexpLength, 
+                                flagWideSrc, flagSrcLength, true);
+        if (pState) {
+            while (true) {
+                printf("string : ");
+                scanf("%s", str);
+                if (*str != '"') 
+                    break;
+                else {
+                    int strLength = strlen(str + 1) - 1;
+                    REchar *widestr = widen(str + 1, strLength);
+                    result = REExecute(pState, widestr, strLength);
+                    if (result) {
+                        printf("\"");
+                        for (i = 0; i < result->length; i++) 
+                            printf("%c", str[i + 1 + result->endIndex]);
+                        printf("\"");
+                        for (i = 0; i < result->n; i++) {
+                            printf(",");
+                            if (result->parens[i].index != -1) {
+                                printf("\"");
+                                for (j = 0; j < result->parens[i].length; j++) 
+                                    printf("%c", str[j + 1 + result->parens[i].index]);
+                                printf("\"");
+                            }
+                            else
+                                printf("undefined");
+                        }
+                        printf("\n");
+                        free(result);
+                    }
+                    else
+                        printf("failed\n");
+                    free(widestr);
+                }
+            }
+            freeRegExp(pState);
+        }
+        else
+            printf("regexp failed to parse\n");
+        free(regexpWideSrc);
+        free(flagWideSrc);
+    }
+    return 0;
+}
+#endif
+
+
diff --git a/mozilla/js2/src/regexp/regexp.h b/mozilla/js2/src/regexp/regexp.h
new file mode 100644
index 00000000000..50e7e917237
--- /dev/null
+++ b/mozilla/js2/src/regexp/regexp.h
@@ -0,0 +1,118 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#ifdef __GNUC__
+ /* GCC's wchar_t is 32 bits, so we can't use it. */
+ typedef uint16 char16;
+ typedef uint16 uchar16;
+#else
+ typedef wchar_t char16;
+ typedef wchar_t uchar16;
+#endif
+typedef char16 REchar;
+
+typedef unsigned int REuint32;
+typedef int REint32;
+
+#ifdef STANDALONE
+typedef unsigned char REbool;
+enum { false, true };
+#else
+typedef bool REbool;
+#endif
+
+typedef enum RE_FLAGS {
+    MULTILINE = 0x1,
+    IGNORECASE = 0x2,
+    GLOBAL = 0x4
+} RE_FLAGS;
+
+typedef enum REError {
+    NO_ERROR,
+    TRAILING_SLASH,         /* an backslash just before the end of the RE */
+    UNCLOSED_PAREN,         /* mis-matched parens */
+    UNCLOSED_BRACKET,       /* mis-matched parens */
+    UNCLOSED_CLASS,         /* '[' missing ']' */
+    BACKREF_IN_CLASS,       /* used '\<digit>' in '[..]' */
+    BAD_FLAG,               /* unrecognized flag (not i, g or m) */
+    OUT_OF_MEMORY
+} REError;
+
+typedef struct RENode RENode;
+
+typedef struct REParseState {
+    const REchar *src;          /* current parse position */
+    const REchar *srcEnd;       /* end of source text */
+    RENode *result;             /* head of result tree */
+    REuint32 parenCount;        /* # capturing parens */
+    REuint32 flags;             /* flags from regexp */
+    REint32 lastIndex;          /* position from last match (for 'g' flag) */
+    REbool oldSyntax;
+    REError error;              /* parse-time error */
+} REParseState;
+
+typedef struct RECapture {
+    REint32 index;              /* start of contents of this capture, -1 for empty  */
+    REuint32 length;            /* length of capture */
+} RECapture;
+
+typedef struct REState {
+    REuint32 endIndex;
+    REuint32 length;            /* the length of a succesful match */
+    REuint32 n;                 /* set to (n - 1), i.e. for /((a)b)/, this field is 1 */
+    RECapture parens[1];        /* first of 'n' captures, allocated at end of this struct */
+} REState;
+
+
+/* 
+ *  Compiles the RegExp source into a tree of RENodes in the returned
+ *  parse state result field. Errors are flagged via the error reporter
+ *  function and signalled via a NULL return.
+ *  The RegExp source does not have any delimiters and the flag string is
+ *  to be supplied separately (can be NULL, with a 0 length)
+ */
+REParseState *REParse(const REchar *source, REuint32 sourceLength, const REchar *flags, REuint32 flagsLength, REbool oldSyntax);
+
+
+/*
+ *  Execute the RegExp against the supplied text, filling in the REState.
+ *
+ *
+ */
+REState *REExecute(REParseState *parseState, const REchar *text, REuint32 length);
+
+
+/*
+ *  Throw away the RegExp and all data associated with it.
+ */
+void freeRegExp(REParseState *parseState);
diff --git a/mozilla/js2/src/regexpwrapper.cpp b/mozilla/js2/src/regexpwrapper.cpp
new file mode 100644
index 00000000000..e699313bf7a
--- /dev/null
+++ b/mozilla/js2/src/regexpwrapper.cpp
@@ -0,0 +1,38 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ *
+ * The contents of this file are subject to the Netscape Public
+ * License Version 1.1 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.mozilla.org/NPL/
+ *
+ * Software distributed under the License is distributed on an "AS
+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr
+ * implied. See the License for the specific language governing
+ * rights and limitations under the License.
+ *
+ * The Original Code is the JavaScript 2 Prototype.
+ *
+ * The Initial Developer of the Original Code is Netscape
+ * Communications Corporation.  Portions created by Netscape are
+ * Copyright (C) 1998 Netscape Communications Corporation. All
+ * Rights Reserved.
+ *
+ * Contributor(s): 
+ *
+ * Alternatively, the contents of this file may be used under the
+ * terms of the GNU Public License (the "GPL"), in which case the
+ * provisions of the GPL are applicable instead of those above.
+ * If you wish to allow use of your version of this file only
+ * under the terms of the GPL and not to allow others to use your
+ * version of this file under the NPL, indicate your decision by
+ * deleting the provisions above and replace them with the notice
+ * and other provisions required by the GPL.  If you do not delete
+ * the provisions above, a recipient may use your version of this
+ * file under either the NPL or the GPL.
+ */
+
+#include "systemtypes.h"
+#include "utilities.h"
+
+#include "regexp.c"
+
diff --git a/mozilla/js2/src/winbuild/dikdik.dsp b/mozilla/js2/src/winbuild/dikdik.dsp
index b2d1f2f31a3..86f718111e8 100644
--- a/mozilla/js2/src/winbuild/dikdik.dsp
+++ b/mozilla/js2/src/winbuild/dikdik.dsp
@@ -41,7 +41,7 @@ RSC=rc.exe
 # PROP Intermediate_Dir "Release"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
-# ADD CPP /nologo /GR /GX /O2 /Ob2 /D "_LIB" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "XP_PC" /YX /FD /c
+# ADD CPP /nologo /GR /GX /O2 /Ob2 /I "../../../js/src/fdlibm" /I "../../../regexp" /D "_LIB" /D "NDEBUG" /D "WIN32" /D "_MBCS" /D "XP_PC" /YX /FD /c
 # ADD BASE RSC /l 0x409 /d "NDEBUG"
 # ADD RSC /l 0x409 /d "NDEBUG"
 BSC32=bscmake.exe
@@ -64,7 +64,7 @@ LIB32=link.exe -lib
 # PROP Intermediate_Dir "DikDik___Win32_Debug"
 # PROP Target_Dir ""
 # ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
-# ADD CPP /nologo /W3 /Gm /GR /GX /ZI /Od /I "../../../js/src/fdlibm" /D "_LIB" /D "DEBUG" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "XP_PC" /FR /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GR /GX /ZI /Od /I "../../../js/src/fdlibm" /I "../../../regexp" /D "_LIB" /D "DEBUG" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "XP_PC" /FR /YX /FD /GZ /c
 # ADD BASE RSC /l 0x409 /d "_DEBUG"
 # ADD RSC /l 0x409 /d "_DEBUG"
 BSC32=bscmake.exe
@@ -89,10 +89,12 @@ SOURCE=..\bytecodegen.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -102,10 +104,12 @@ SOURCE=..\exception.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -115,10 +119,12 @@ SOURCE=..\fdlibm_ns.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -128,10 +134,12 @@ SOURCE=..\formatter.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -141,16 +149,29 @@ SOURCE=..\hash.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
 # Begin Source File
 
 SOURCE=..\js2execution.cpp
+
+!IF  "$(CFG)" == "DikDik - Win32 Release"
+
+# ADD CPP /I "../../../js/src/fdlibm" /I "../../regexp"
+
+!ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
+
+# ADD CPP /I "../../../regexp"
+
+!ENDIF 
+
 # End Source File
 # Begin Source File
 
@@ -158,10 +179,12 @@ SOURCE=..\js2runtime.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -171,16 +194,29 @@ SOURCE=..\jsarray.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
 # Begin Source File
 
 SOURCE=..\jsdate.cpp
+
+!IF  "$(CFG)" == "DikDik - Win32 Release"
+
+# ADD CPP /I "../../../js/src/fdlibm" /I "../../regexp"
+
+!ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
+
+# ADD CPP /I "../../../regexp"
+
+!ENDIF 
+
 # End Source File
 # Begin Source File
 
@@ -188,10 +224,12 @@ SOURCE=..\jsmath.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -201,10 +239,12 @@ SOURCE=..\jsstring.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -214,10 +254,12 @@ SOURCE=..\lexer.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -227,10 +269,12 @@ SOURCE=..\mem.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -240,10 +284,12 @@ SOURCE=..\numerics.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -253,16 +299,29 @@ SOURCE=..\parser.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
 # Begin Source File
 
 SOURCE=..\prmjtime.cpp
+
+!IF  "$(CFG)" == "DikDik - Win32 Release"
+
+# ADD CPP /I "../../../js/src/fdlibm" /I "../../regexp"
+
+!ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
+
+# ADD CPP /I "../../../regexp"
+
+!ENDIF 
+
 # End Source File
 # Begin Source File
 
@@ -270,23 +329,31 @@ SOURCE=..\reader.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
 # Begin Source File
 
+SOURCE=..\regexpwrapper.cpp
+# End Source File
+# Begin Source File
+
 SOURCE=..\strings.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -296,16 +363,29 @@ SOURCE=..\token.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
 # Begin Source File
 
 SOURCE=..\tracer.cpp
+
+!IF  "$(CFG)" == "DikDik - Win32 Release"
+
+# ADD CPP /I "../../../js/src/fdlibm" /I "../../regexp"
+
+!ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
+
+# ADD CPP /I "../../../regexp"
+
+!ENDIF 
+
 # End Source File
 # Begin Source File
 
@@ -313,10 +393,12 @@ SOURCE=..\utilities.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -326,10 +408,12 @@ SOURCE=..\world.cpp
 
 !IF  "$(CFG)" == "DikDik - Win32 Release"
 
-# ADD CPP /W4 /GR
+# ADD CPP /W4 /GR /I "../../../js/src/fdlibm" /I "../../regexp"
 
 !ELSEIF  "$(CFG)" == "DikDik - Win32 Debug"
 
+# ADD CPP /I "../../../regexp"
+
 !ENDIF 
 
 # End Source File
@@ -415,6 +499,10 @@ SOURCE=..\reader.h
 # End Source File
 # Begin Source File
 
+SOURCE=..\..\..\regexp\regexp.h
+# End Source File
+# Begin Source File
+
 SOURCE=..\stlcfg.h
 # End Source File
 # Begin Source File