From 1aa9f3eb116165b85ea8716e7f555b5d0cea85f3 Mon Sep 17 00:00:00 2001
From: "rogerl%netscape.com"
 <rogerl%netscape.com@18797224-902f-48f8-a5cc-f745e15eee43>
Date: Tue, 3 Sep 2002 15:20:24 +0000
Subject: [PATCH] Labor day progress. DotReference, class instance variable
 definition and associated oevrride resolution support. Branch logic support.

git-svn-id: svn://10.0.0.236/trunk@128706 18797224-902f-48f8-a5cc-f745e15eee43
---
 mozilla/js2/src/bytecodecontainer.cpp |  83 ++++-
 mozilla/js2/src/bytecodecontainer.h   |  61 +++-
 mozilla/js2/src/epimetheus.cpp        |   5 -
 mozilla/js2/src/js2engine.cpp         |  72 +++-
 mozilla/js2/src/js2engine.h           |  31 +-
 mozilla/js2/src/js2metadata.cpp       | 457 ++++++++++++++++++++++++--
 mozilla/js2/src/js2metadata.h         |  75 ++++-
 mozilla/js2/src/js2op_access.cpp      |  90 ++---
 mozilla/js2/src/js2op_arithmetic.cpp  |  12 +-
 mozilla/js2/src/js2op_flowcontrol.cpp |  80 +++++
 mozilla/js2/src/js2op_invocation.cpp  |  38 ++-
 11 files changed, 867 insertions(+), 137 deletions(-)
 create mode 100644 mozilla/js2/src/js2op_flowcontrol.cpp

diff --git a/mozilla/js2/src/bytecodecontainer.cpp b/mozilla/js2/src/bytecodecontainer.cpp
index 78cfced1d0b..0d91f9d7f2f 100644
--- a/mozilla/js2/src/bytecodecontainer.cpp
+++ b/mozilla/js2/src/bytecodecontainer.cpp
@@ -60,14 +60,34 @@
 namespace JavaScript {
 namespace MetaData {
 
-
-
-    BytecodeContainer::~BytecodeContainer() 
-    { 
-	for (std::vector<Multiname *>::iterator i = mMultinameList.begin(), end = mMultinameList.end(); (i != end); i++)
-	    delete *i;
+    // Establish the label's location in a bytecode container
+    void Label::setLocation(BytecodeContainer *bCon, uint32 location)
+    {
+        mHasLocation = true;
+        mLocation = location;
+        for (std::vector<uint32>::iterator i = mFixupList.begin(), end = mFixupList.end(); 
+                        (i != end); i++)
+        {
+            uint32 branchLocation = *i;
+            bCon->setOffset(branchLocation, int32(mLocation - branchLocation)); 
+        }
     }
 
+    // Add a branch location to the list of fixups for this label
+    // (or resolve the branch if the location is known already)
+    void Label::addFixup(BytecodeContainer *bCon, uint32 branchLocation) 
+    { 
+        if (mHasLocation)
+            bCon->addOffset(int32(mLocation - branchLocation));
+        else {
+            mFixupList.push_back(branchLocation); 
+            bCon->addLong(0);
+        }
+    }
+
+
+
+    // Look up the pc and return a position from the map
     size_t BytecodeContainer::getPosition(uint16 pc)
     {
         for (std::vector<MapEntry>::iterator i = pcMap.begin(), end = pcMap.end(); (i != end); i++)
@@ -76,6 +96,57 @@ namespace MetaData {
         return 0;
     }
 
+
+    // insert the opcode, marking it's position in the pcmap and
+    // adjusting the stack as appropriate.
+    void BytecodeContainer::emitOp(JS2Op op, size_t pos)
+    { 
+        adjustStack(op); 
+        addByte((uint8)op); 
+        pcMap.push_back(MapEntry(mBuffer.size(), pos)); 
+    }
+
+    // insert the opcode, marking it's position in the pcmap and
+    // adjusting the stack as supplied.
+    void BytecodeContainer::emitOp(JS2Op op, size_t pos, int32 effect)     
+    {
+        adjustStack(op, effect); 
+        addByte((uint8)op); 
+        pcMap.push_back(std::pair<uint16, size_t>(mBuffer.size(), pos)); 
+    }
+
+    // Track the high-water mark for the stack 
+    // and watch for a bad negative stack
+    void BytecodeContainer::adjustStack(JS2Op op, int32 effect)
+    { 
+        mStackTop += effect; 
+        if (mStackTop > mStackMax) 
+            mStackMax = mStackTop; 
+        ASSERT(mStackTop >= 0); 
+    }
+
+    // get a new label
+    BytecodeContainer::LabelID BytecodeContainer::getLabel()
+    {
+        LabelID result = mLabelList.size();
+        mLabelList.push_back(Label());
+        return result;
+    }
+    // set the current pc as needing a fixup to a label
+    void BytecodeContainer::addFixup(LabelID label) 
+    { 
+        ASSERT(label < mLabelList.size());
+        mLabelList[label].addFixup(this, mBuffer.size()); 
+    }
+    // set the current pc as the position for a label
+    void BytecodeContainer::setLabel(LabelID label)
+    {
+        ASSERT(label < mLabelList.size());
+        mLabelList[label].setLocation(this, mBuffer.size()); 
+    }
+
+
+
 }
 }
 
diff --git a/mozilla/js2/src/bytecodecontainer.h b/mozilla/js2/src/bytecodecontainer.h
index 0f9259ae3e2..c3c3b7499f9 100644
--- a/mozilla/js2/src/bytecodecontainer.h
+++ b/mozilla/js2/src/bytecodecontainer.h
@@ -47,6 +47,40 @@
 namespace JavaScript {
 namespace MetaData {
 
+class BytecodeContainer;
+    
+class Label {
+public:
+    
+    typedef enum { InternalLabel, NamedLabel, BreakLabel, ContinueLabel } LabelKind;
+
+    Label() : mKind(InternalLabel), mHasLocation(false) { }
+    Label(LabelStmtNode *lbl) : mKind(NamedLabel), mHasLocation(false), mLabelStmt(lbl) { }
+    Label(LabelKind kind) : mKind(kind), mHasLocation(false) { }
+
+    bool matches(const StringAtom *name)
+    {
+        return ((mKind == NamedLabel) && (mLabelStmt->name.compare(*name) == 0));
+    }
+
+    bool matches(LabelKind kind)
+    {
+        return (mKind == kind);
+    }
+
+    void addFixup(BytecodeContainer *bcg, uint32 branchLocation);        
+    void setLocation(BytecodeContainer *bcg, uint32 location);
+
+    std::vector<uint32> mFixupList;
+
+    LabelKind mKind;
+    bool mHasLocation;
+    LabelStmtNode *mLabelStmt;
+
+    uint32 mLocation;
+};
+
+
 
 class Multiname;
 class Frame;
@@ -54,22 +88,25 @@ class Frame;
 class BytecodeContainer {
 public:
     BytecodeContainer() : mStackTop(0), mStackMax(0) { }
-    BytecodeContainer::~BytecodeContainer() ;
+    BytecodeContainer::~BytecodeContainer()          { }
 
     
     uint8 *getCodeStart()                   { return mBuffer.begin(); }
 
     typedef std::pair<uint16, size_t> MapEntry;
     std::vector<MapEntry> pcMap;
+    typedef uint32 LabelID;
 
     size_t getPosition(uint16 pc);
 
-    void emitOp(JS2Op op, size_t pos)       { adjustStack(op); addByte((uint8)op); pcMap.push_back(MapEntry(mBuffer.size(), pos)); }
-    void emitOp(JS2Op op, size_t pos, int32 effect)     
-                                            { adjustStack(op, effect); addByte((uint8)op); pcMap.push_back(std::pair<uint16, size_t>(mBuffer.size(), pos)); }
+    void emitOp(JS2Op op, size_t pos);
+    void emitOp(JS2Op op, size_t pos, int32 effect);
+
+    void emitBranch(JS2Op op, LabelID tgt, size_t pos)
+                                            { emitOp(op, pos); addFixup(tgt); }
 
     void adjustStack(JS2Op op)              { adjustStack(op, JS2Engine::getStackEffect(op)); }
-    void adjustStack(JS2Op op, int32 effect){ mStackTop += effect; if (mStackTop > mStackMax) mStackMax = mStackTop; ASSERT(mStackTop >= 0); }
+    void adjustStack(JS2Op op, int32 effect);
 
     void addByte(uint8 v)                   { mBuffer.push_back(v); }
     
@@ -89,12 +126,15 @@ public:
 
     void addFrame(Frame *f)                 { mFrameList.push_back(f); addShort(mFrameList.size() - 1); }
 
+    void addOffset(int32 v)                 { mBuffer.insert(mBuffer.end(), (uint8 *)&v, (uint8 *)(&v) + sizeof(int32)); }
+    void setOffset(uint32 index, int32 v)   { *((int32 *)(mBuffer.begin() + index)) = v; }
     
     void addString(const StringAtom &x, size_t pos)     { emitOp(eString, pos); addPointer(&x); }
     void addString(String &x, size_t pos)               { emitOp(eString, pos); addPointer(&x); }
     void addString(String *x, size_t pos)               { emitOp(eString, pos); addPointer(x); }
     static String *getString(void *pc)      { return (String *)getPointer(pc); }
-    // XXX We lose StringAtom here - is there anyway of stashing these in a bytecodecontainer?
+    // XXX We lose StringAtom here (and is it safe to stash the address of a StringAtom?)
+    // - is there any way of keeping StringAtoms themselves in a bytecodeContainer?
     
     typedef std::vector<uint8> CodeBuffer;
 
@@ -102,9 +142,14 @@ public:
     std::vector<Multiname *> mMultinameList;      // gc tracking 
     std::vector<Frame *> mFrameList;              // gc tracking 
 
-    int32 mStackTop;                // keep these as signed so as to
-    int32 mStackMax;                // track if they go negative.
+    int32 mStackTop;                // keep these as signed so as to...
+    int32 mStackMax;                // ...track if they go negative.
 
+    std::vector<Label> mLabelList;
+
+    LabelID getLabel();
+    void addFixup(LabelID label);
+    void setLabel(LabelID label);
 };
 
 
diff --git a/mozilla/js2/src/epimetheus.cpp b/mozilla/js2/src/epimetheus.cpp
index c65ac311fb7..18f620639c2 100644
--- a/mozilla/js2/src/epimetheus.cpp
+++ b/mozilla/js2/src/epimetheus.cpp
@@ -44,11 +44,6 @@
 #include "bytecodecontainer.h"
 #include "js2metadata.h"
 
-#ifdef DEBUG
-#include "tracer.h"
-#include "collector.h"
-#endif
-
 #if defined(XP_MAC) && !defined(XP_MAC_MPW)
 #include <SIOUX.h>
 #include <MacTypes.h>
diff --git a/mozilla/js2/src/js2engine.cpp b/mozilla/js2/src/js2engine.cpp
index 51e610ee270..d49d7218eae 100644
--- a/mozilla/js2/src/js2engine.cpp
+++ b/mozilla/js2/src/js2engine.cpp
@@ -80,6 +80,7 @@ js2val JS2Engine::interpreterLoop()
 #include "js2op_invocation.cpp"
 #include "js2op_access.cpp"
 #include "js2op_literal.cpp"
+#include "js2op_flowcontrol.cpp"
         }
     }
     return retval;
@@ -200,6 +201,27 @@ float64 JS2Engine::convertValueToDouble(js2val x)
 
 }
 
+// x is not a bool
+bool JS2Engine::convertValueToBoolean(js2val x)
+{
+    if (JS2VAL_IS_UNDEFINED(x))
+        return false;
+    if (JS2VAL_IS_NULL(x))
+        return false;
+    if (JS2VAL_IS_INT(x))
+        return (JS2VAL_TO_INT(x) != 0);
+    if (JS2VAL_IS_DOUBLE(x)) {
+        float64 *xd = JS2VAL_TO_DOUBLE(x);
+        return ! (JSDOUBLE_IS_POSZERO(*xd) || JSDOUBLE_IS_NEGZERO(*xd) || JSDOUBLE_IS_NaN(*xd));
+    }
+    if (JS2VAL_IS_STRING(x)) {
+        String *str = JS2VAL_TO_STRING(x);
+        return (str->length() != 0);
+    }
+    return true;
+}
+
+
 #define INIT_STRINGATOM(n) n##_StringAtom(world.identifiers[#n])
 
 JS2Engine::JS2Engine(World &world)
@@ -226,28 +248,47 @@ int JS2Engine::getStackEffect(JS2Op op)
 {
     switch (op) {
     case eReturn:
-    case ePlus:
-        return -1;
+        return -1;  
+
+    case eAdd:          // pop two, push one
+    case eSubtract:
+        return -1;  
 
     case eString:
     case eTrue:
     case eFalse:
     case eNumber:
-        return 1;
+        return 1;       // push literal value
 
     case eLexicalRead:
-        return 0;       // consumes a multiname, pushes the value
+        return 1;       // push the value
     case eLexicalWrite:
-        return -2;      // consumes a multiname and the value
+        return -1;      // pop the value
+
+    case eDotRead:
+        return 0;       // pop a base, push the value
+    case eDotWrite:
+        return -2;      // pop a base and the value
 
     case eReturnVoid:
+    case eBranch:
+        return 0;
+
+    case eToBoolean:    // pop object, push boolean
         return 0;
 
     case eMultiname:
         return 1;       // push the multiname object
 
-    case ePushFrame:
-    case ePopFrame:
+    case ePushFrame:    // affect the frame stack...
+    case ePopFrame:     // ...not the exec stack
+        return 0;
+
+    case eBranchFalse:
+    case eBranchTrue:
+        return -1;      // pop the boolean condition
+
+    case eNew:          // pop the class or function, push the new instance
         return 0;
 
     default:
@@ -261,5 +302,22 @@ size_t JS2Engine::errorPos()
     return bCon->getPosition(pc - bCon->getCodeStart()); 
 }
 
+JS2Object *JS2Engine::defaultConstructor(JS2Engine *engine)
+{
+    js2val v = engine->pop();
+    ASSERT(JS2VAL_IS_OBJECT(v) && !JS2VAL_IS_NULL(v));
+    JS2Object *obj = JS2VAL_TO_OBJECT(v);
+    ASSERT(obj->kind == ClassKind);
+    JS2Class *c = checked_cast<JS2Class *>(obj);
+    if (c->dynamic)
+        return new DynamicInstance(c);
+    else
+        if (c->prototype)
+            return new PrototypeInstance(NULL);
+        else
+            return new FixedInstance(c);
+}
+
+
 }
 }
\ No newline at end of file
diff --git a/mozilla/js2/src/js2engine.h b/mozilla/js2/src/js2engine.h
index a15f15dc6b0..b1253747e63 100644
--- a/mozilla/js2/src/js2engine.h
+++ b/mozilla/js2/src/js2engine.h
@@ -49,23 +49,30 @@ namespace MetaData {
 
 
 enum JS2Op {
-    ePlus,
+    eAdd,
+    eSubtract,
     eTrue,
     eFalse,
     eNumber,
-    eString,            // <string pointer>
-    eObject,            // <named argument count>
-    eLexicalRead,
-    eLexicalWrite,
+    eString,            // <string pointer:u32>
+    eNewObject,         // <argCount:u16>
+    eLexicalRead,       // <multiname index:u16>
+    eLexicalWrite,      // <multiname index:u16>
+    eDotRead,           // <multiname index:u16>
+    eDotWrite,          // <multiname index:u16>
     eReturn,
     eReturnVoid,
-    eNewObject,         // <argCount:16>
-    eMultiname,         // <multiname index>
-    ePushFrame,         // <frame index>
-    ePopFrame
+    ePushFrame,         // <frame index:u16>
+    ePopFrame,
+    eToBoolean,
+    eBranchFalse,       // <branch displacement:s32> XXX save space with short and long versions instead ?
+    eBranchTrue,        // <branch displacement:s32>
+    eBranch,            // <branch displacement:s32>
+    eNew
 };
 
 
+class JS2Object;
 class JS2Metadata;
 class BytecodeContainer;
 
@@ -89,14 +96,17 @@ public:
 
     void push(js2val x) { ASSERT(sp < (execStack + MAX_EXEC_STACK)); *sp++ = x; }
     js2val pop()        { ASSERT(sp > execStack); return *--sp; }
+    js2val top()        { return *(sp - 1); }
 
     String *convertValueToString(js2val x);
     js2val convertValueToPrimitive(js2val x);
     float64 convertValueToDouble(js2val x);
+    bool convertValueToBoolean(js2val x);
 
     String *toString(js2val x)      { if (JS2VAL_IS_STRING(x)) return JS2VAL_TO_STRING(x); else return convertValueToString(x); }
     js2val toPrimitive(js2val x)    { if (JS2VAL_IS_PRIMITIVE(x)) return x; else return convertValueToPrimitive(x); }
     float64 toNumber(js2val x)      { if (JS2VAL_IS_INT(x)) return JS2VAL_TO_INT(x); else if (JS2VAL_IS_DOUBLE(x)) return *JS2VAL_TO_DOUBLE(x); else return convertValueToDouble(x); }
+    bool toBoolean(js2val x)        { if (JS2VAL_IS_BOOLEAN(x)) return JS2VAL_TO_BOOLEAN(x); else return convertValueToBoolean(x); }
 
     uint8 *pc;
     BytecodeContainer *bCon;
@@ -119,6 +129,9 @@ public:
     js2val *sp;
     
 
+    static JS2Object *defaultConstructor(JS2Engine *engine);
+
+
     static int getStackEffect(JS2Op op);
 
 
diff --git a/mozilla/js2/src/js2metadata.cpp b/mozilla/js2/src/js2metadata.cpp
index cef8f92d987..554292b5468 100644
--- a/mozilla/js2/src/js2metadata.cpp
+++ b/mozilla/js2/src/js2metadata.cpp
@@ -102,6 +102,21 @@ namespace MetaData {
                 ValidateStmt(cxt, env, l->stmt);
             }
             break;
+        case StmtNode::If:
+            {
+                UnaryStmtNode *i = checked_cast<UnaryStmtNode *>(p);
+                ValidateExpression(cxt, env, i->expr);
+                ValidateStmt(cxt, env, i->stmt);
+            }
+            break;
+        case StmtNode::IfElse:
+            {
+                BinaryStmtNode *i = checked_cast<BinaryStmtNode *>(p);
+                ValidateExpression(cxt, env, i->expr);
+                ValidateStmt(cxt, env, i->stmt);
+                ValidateStmt(cxt, env, i->stmt2);
+            }
+            break;
         case StmtNode::Var:
         case StmtNode::Const:
             {
@@ -144,6 +159,28 @@ namespace MetaData {
                                 // the type and the value are 'future'
                             }
                             break;
+                        case Attribute::Abstract:
+                        case Attribute::Virtual:
+                        case Attribute::Final: 
+                            {
+                                JS2Class *c = checked_cast<JS2Class *>(env->getTopFrame());
+                                InstanceMember *m = NULL;
+                                switch (memberMod) {
+                                case Attribute::Abstract:
+                                    if (v->initializer)
+                                        reportError(Exception::syntaxError, "Abstract member may not have initializer", p->pos);
+                                    m = new InstanceAccessor(NULL, false);
+                                    break;
+                                case Attribute::Virtual:
+                                    m = new InstanceVariable(immutable, false);
+                                    break;
+                                case Attribute::Final: 
+                                    m = new InstanceVariable(immutable, true);
+                                    break;
+                                }
+                                defineInstanceMember(c, cxt, *name, a->namespaces, a->overrideMod, a->xplicit, ReadWriteAccess, m, p->pos);
+                            }
+                            break;
                         }
                     }
 
@@ -230,7 +267,7 @@ namespace MetaData {
                     reportError(Exception::definitionError, "Illegal modifier for class definition", p->pos);
                     break;
                 }
-                JS2Class *c = new JS2Class(superClass, proto, new Namespace(engine->public_StringAtom), (a->dynamic || superClass->dynamic), final);
+                JS2Class *c = new JS2Class(superClass, proto, new Namespace(engine->private_StringAtom), (a->dynamic || superClass->dynamic), final, classStmt->name);
                 classStmt->c = c;
                 Variable *v = new Variable(classClass, OBJECT_TO_JS2VAL(c), true);
                 defineStaticMember(env, classStmt->name, a->namespaces, a->overrideMod, a->xplicit, ReadWriteAccess, v, p->pos);
@@ -291,6 +328,34 @@ namespace MetaData {
                 EvalStmt(env, phase, l->stmt);
             }
             break;
+        case StmtNode::If:
+            {
+                BytecodeContainer::LabelID skipOverStmt = bCon->getLabel();
+                UnaryStmtNode *i = checked_cast<UnaryStmtNode *>(p);
+                Reference *r = EvalExprNode(env, phase, i->expr);
+                if (r) r->emitReadBytecode(bCon, p->pos);
+                bCon->emitOp(eToBoolean, p->pos);
+                bCon->emitBranch(eBranchFalse, skipOverStmt, p->pos);
+                EvalStmt(env, phase, i->stmt);
+                bCon->setLabel(skipOverStmt);
+            }
+            break;
+        case StmtNode::IfElse:
+            {
+                BytecodeContainer::LabelID falseStmt = bCon->getLabel();
+                BytecodeContainer::LabelID skipOverFalseStmt = bCon->getLabel();
+                BinaryStmtNode *i = checked_cast<BinaryStmtNode *>(p);
+                Reference *r = EvalExprNode(env, phase, i->expr);
+                if (r) r->emitReadBytecode(bCon, p->pos);
+                bCon->emitOp(eToBoolean, p->pos);
+                bCon->emitBranch(eBranchFalse, falseStmt, p->pos);
+                EvalStmt(env, phase, i->stmt);
+                bCon->emitBranch(eBranch, skipOverFalseStmt, p->pos);
+                bCon->setLabel(falseStmt);
+                EvalStmt(env, phase, i->stmt2);
+                bCon->setLabel(skipOverFalseStmt);
+            }
+            break;
         case StmtNode::Var:
         case StmtNode::Const:
             {
@@ -593,11 +658,15 @@ namespace MetaData {
             break;
         case ExprNode::dot:
             {
+                BinaryExprNode *b = checked_cast<BinaryExprNode *>(p);
+                ValidateExpression(cxt, env, b->op1);
+                ValidateExpression(cxt, env, b->op2);
             }
             break;
 
         case ExprNode::assignment:
         case ExprNode::add:
+        case ExprNode::subtract:
             {
                 BinaryExprNode *b = checked_cast<BinaryExprNode *>(p);
                 ValidateExpression(cxt, env, b->op1);
@@ -610,6 +679,17 @@ namespace MetaData {
 //                IdentifierExprNode *i = checked_cast<IdentifierExprNode *>(p);
             }
             break;
+        case ExprNode::New: 
+            {
+                InvokeExprNode *i = checked_cast<InvokeExprNode *>(p);
+                ValidateExpression(cxt, env, i->op);
+                ExprPairList *args = i->pairs;
+                while (args) {
+                    ValidateExpression(cxt, env, args->value);
+                    args = args->next;
+                }
+            }
+            break;
         default:
             NOT_REACHED("Not Yet Implemented");
         } // switch (p->getKind())
@@ -638,6 +718,7 @@ namespace MetaData {
     Reference *JS2Metadata::EvalExprNode(Environment *env, Phase phase, ExprNode *p)
     {
         Reference *returnRef = NULL;
+        JS2Op binaryOp;
 
         switch (p->getKind()) {
 
@@ -656,13 +737,19 @@ namespace MetaData {
             }
             break;
         case ExprNode::add:
+            binaryOp = eAdd;
+            goto doBinary;
+        case ExprNode::subtract:
+            binaryOp = eSubtract;
+            goto doBinary;
+doBinary:
             {
                 BinaryExprNode *b = checked_cast<BinaryExprNode *>(p);
                 Reference *lVal = EvalExprNode(env, phase, b->op1);
                 if (lVal) lVal->emitReadBytecode(bCon, p->pos);
                 Reference *rVal = EvalExprNode(env, phase, b->op2);
                 if (rVal) rVal->emitReadBytecode(bCon, p->pos);
-                bCon->emitOp(ePlus, p->pos);
+                bCon->emitOp(binaryOp, p->pos);
             }
             break;
 
@@ -684,7 +771,7 @@ namespace MetaData {
         case ExprNode::qualify:
             {
                 QualifyExprNode *qe = checked_cast<QualifyExprNode *>(p);
-                const StringAtom &name = checked_cast<IdentifierExprNode *>(p)->name;
+                const StringAtom &name = qe->name;
 
                 js2val av = EvalExpression(env, CompilePhase, qe->qualifier);
                 if (JS2VAL_IS_NULL(av) || !JS2VAL_IS_OBJECT(av))
@@ -695,6 +782,7 @@ namespace MetaData {
                 Namespace *ns = checked_cast<Namespace *>(obj);
                 
                 returnRef = new LexicalReference(name, ns, cxt.strict);
+                // Calling emitBindBytecode causes the multiname to get loaded onto the stack
                 ((LexicalReference *)returnRef)->emitBindBytecode(bCon, p->pos);
             }
             break;
@@ -706,6 +794,27 @@ namespace MetaData {
                 ((LexicalReference *)returnRef)->emitBindBytecode(bCon, p->pos);
             }
             break;
+        case ExprNode::dot:
+            {
+                BinaryExprNode *b = checked_cast<BinaryExprNode *>(p);
+                Reference *baseVal = EvalExprNode(env, phase, b->op1);
+                if (baseVal) baseVal->emitReadBytecode(bCon, p->pos);
+
+                if (b->op2->getKind() == ExprNode::identifier) {
+                    returnRef = new DotReference(i->name);
+                    ((DotReference *)returnRef)->emitBindBytecode(bCon, p->pos);
+                } 
+                else {
+                    if (b->op2->getKind() == ExprNode::qualify) {
+                        Reference *rVal = EvalExprNode(env, phase, b->op2);                        
+                        ASSERT(rVal && checked_cast<LexicalReference *>(rVal));
+                        returnRef = new DotReference(((LexicalReference *)rVal)->variableMultiname);
+                        ((DotReference *)returnRef)->emitBindBytecode(bCon, p->pos);
+                    }
+                    // else bracketRef...
+                }
+            }
+            break;
         case ExprNode::boolean:
             if (checked_cast<BooleanExprNode *>(p)->value) 
                 bCon->emitOp(eTrue, p->pos);
@@ -741,15 +850,19 @@ namespace MetaData {
                 bCon->addShort(argCount);
             }
             break;
-        case ExprNode::dot:
+        case ExprNode::New: 
             {
-                BinaryExprNode *b = checked_cast<BinaryExprNode *>(p);
-                if (b->op2->getKind() == ExprNode::identifier) {
-                }
-                else {
-                if (b->op2->getKind() == ExprNode::qualify) {
-                }
+                InvokeExprNode *i = checked_cast<InvokeExprNode *>(p);
+                Reference *rVal = EvalExprNode(env, phase, i->op);
+                if (rVal) rVal->emitReadBytecode(bCon, p->pos);
+                ExprPairList *args = i->pairs;
+                uint32 argCount = 0;
+                while (args) {
+                    EvalExprNode(env, phase, args->value);
+                    argCount++;
+                    args = args->next;
                 }
+                bCon->emitOp(eNew, p->pos);
             }
             break;
         default:
@@ -787,7 +900,7 @@ namespace MetaData {
             prev = pf;
             pf = pf->nextFrame;
         }
-        if (pf->nextFrame && (pf->kind == ClassKind))
+        if ((pf != firstFrame) && (pf->kind == ClassKind))
             pf = prev;
         return pf;
     }
@@ -980,7 +1093,165 @@ namespace MetaData {
 
     }
 
-    
+    // Look through 'c' and all it's super classes for a identifier 
+    // matching the qualified name and access.
+    InstanceMember *JS2Metadata::findInstanceMember(JS2Class *c, QualifiedName *qname, Access access)
+    {
+        if (qname == NULL)
+            return NULL;
+        JS2Class *s = c;
+        while (s) {
+            if (access & ReadAccess) {
+                for (InstanceBindingIterator b = s->instanceReadBindings.lower_bound(qname->id),
+                        end = s->instanceReadBindings.upper_bound(qname->id); (b != end); b++) {
+                    if (*qname == b->second->qname)
+                        return b->second->content;
+                }
+            }        
+            if (access & WriteAccess) {
+                for (InstanceBindingIterator b = s->instanceWriteBindings.lower_bound(qname->id),
+                        end = s->instanceWriteBindings.upper_bound(qname->id); (b != end); b++) {
+                    if (*qname == b->second->qname)
+                        return b->second->content;
+                }
+            }
+            s = s->super;
+        }
+        return NULL;
+    }
+
+    // Examine class 'c' and find all instance members that would be overridden
+    // by 'id' in any of the given namespaces.
+    OverrideStatus *JS2Metadata::searchForOverrides(JS2Class *c, const StringAtom &id, NamespaceList *namespaces, Access access, size_t pos)
+    {
+        OverrideStatus *os = new OverrideStatus(NULL, id);
+        for (NamespaceListIterator ns = namespaces->begin(), end = namespaces->end(); (ns != end); ns++) {
+            QualifiedName qname(*ns, id);
+            InstanceMember *m = findInstanceMember(c, &qname, access);
+            if (m) {
+                os->multiname.addNamespace(*ns);
+                if (os->overriddenMember == NULL)
+                    os->overriddenMember = m;
+                else
+                    if (os->overriddenMember != m)  // different instance members by same id
+                        reportError(Exception::definitionError, "Illegal override", pos);
+            }
+        }
+        return os;
+    }
+
+    // Find the possible override conflicts that arise from the given id and namespaces
+    // Fall back on the currently open namespace list if no others are specified.
+    OverrideStatus *JS2Metadata::resolveOverrides(JS2Class *c, Context *cxt, const StringAtom &id, NamespaceList *namespaces, Access access, bool expectMethod, size_t pos)
+    {
+        OverrideStatus *os = NULL;
+        if ((namespaces == NULL) || namespaces->empty()) {
+            os = searchForOverrides(c, id, &cxt->openNamespaces, access, pos);
+            if (os->overriddenMember == NULL) {
+                ASSERT(os->multiname.nsList.empty());
+                os->multiname.addNamespace(publicNamespace);
+            }
+        }
+        else {
+            OverrideStatus *os2 = searchForOverrides(c, id, namespaces, access, pos);
+            if (os2->overriddenMember == NULL) {
+                OverrideStatus *os3 = searchForOverrides(c, id, &cxt->openNamespaces, access, pos);
+                if (os3->overriddenMember == NULL) {
+                    os->multiname.addNamespace(namespaces);
+                }
+                else {
+                    os->potentialConflict = true;   // Didn't find the member with a specified namespace, but did with
+                                                    // the use'd ones. That'll be an error unless the override is 
+                                                    // disallowed (in defineInstanceMember below)
+                    os->multiname.addNamespace(namespaces);
+                }
+                delete os3;
+                delete os2;
+            }
+            else {
+                os = os2;
+                os->multiname.addNamespace(namespaces);
+            }
+        }
+        // For all the discovered possible overrides, make sure the member doesn't already exist in the class
+        for (NamespaceListIterator nli = os->multiname.nsList.begin(), nlend = os->multiname.nsList.end(); (nli != nlend); nli++) {
+            QualifiedName qname(*nli, id);
+            if (access & ReadAccess) {
+                for (InstanceBindingIterator b = c->instanceReadBindings.lower_bound(id),
+                        end = c->instanceReadBindings.upper_bound(id); (b != end); b++) {
+                    if (qname == b->second->qname)
+                        reportError(Exception::definitionError, "Illegal override", pos);
+                }
+            }        
+            if (access & WriteAccess) {
+                for (InstanceBindingIterator b = c->instanceWriteBindings.lower_bound(id),
+                        end = c->instanceWriteBindings.upper_bound(id); (b != end); b++) {
+                    if (qname == b->second->qname)
+                        reportError(Exception::definitionError, "Illegal override", pos);
+                }
+            }
+        }
+        // Make sure we're getting what we expected
+        if (expectMethod) {
+            if (os->overriddenMember && !os->potentialConflict && (os->overriddenMember->kind != InstanceMember::InstanceMethodKind))
+                reportError(Exception::definitionError, "Illegal override, expected method", pos);
+        }
+        else {
+            if (os->overriddenMember && !os->potentialConflict && (os->overriddenMember->kind == InstanceMember::InstanceMethodKind))
+                reportError(Exception::definitionError, "Illegal override, didn't expect method", pos);
+        }
+
+        return os;
+    }
+
+    OverrideStatusPair JS2Metadata::defineInstanceMember(JS2Class *c, Context *cxt, const StringAtom &id, NamespaceList *namespaces, Attribute::OverrideModifier overrideMod, bool xplicit, Access access, InstanceMember *m, size_t pos)
+    {
+        OverrideStatus *readStatus;
+        OverrideStatus *writeStatus;
+        if (xplicit)
+            reportError(Exception::definitionError, "Illegal use of explicit", pos);
+
+        if (access & ReadAccess)
+            readStatus = resolveOverrides(c, cxt, id, namespaces, ReadAccess, (m->kind == InstanceMember::InstanceMethodKind), pos);
+        else
+            readStatus = new OverrideStatus(NULL, id);
+
+        if (access & WriteAccess)
+            writeStatus = resolveOverrides(c, cxt, id, namespaces, WriteAccess, (m->kind == InstanceMember::InstanceMethodKind), pos);
+        else
+            writeStatus = new OverrideStatus(NULL, id);
+
+        if ((!readStatus->potentialConflict && (readStatus->overriddenMember != NULL))
+                || (!writeStatus->potentialConflict && (writeStatus->overriddenMember != NULL))) {
+            if ((overrideMod != Attribute::DoOverride) && (overrideMod != Attribute::OverrideUndefined))
+                reportError(Exception::definitionError, "Illegal override", pos);
+        }
+        else {
+            if (readStatus->potentialConflict || writeStatus->potentialConflict) {
+                if ((overrideMod != Attribute::DontOverride) && (overrideMod != Attribute::OverrideUndefined))
+                    reportError(Exception::definitionError, "Illegal override", pos);
+            }
+        }
+
+        NamespaceListIterator nli, nlend;
+        for (nli = readStatus->multiname.nsList.begin(), nlend = readStatus->multiname.nsList.end(); (nli != nlend); nli++) {
+            QualifiedName qName(*nli, id);
+            InstanceBinding *ib = new InstanceBinding(qName, m);
+            const InstanceBindingMap::value_type e(id, ib);
+            c->instanceReadBindings.insert(e);
+        }
+        
+        for (nli = writeStatus->multiname.nsList.begin(), nlend = writeStatus->multiname.nsList.end(); (nli != nlend); nli++) {
+            QualifiedName qName(*nli, id);
+            InstanceBinding *ib = new InstanceBinding(qName, m);
+            const InstanceBindingMap::value_type e(id, ib);
+            c->instanceWriteBindings.insert(e);
+        }
+        
+        OverrideStatusPair osp(readStatus, writeStatus);
+        return osp;
+    }
+
     // Define a hoisted var in the current frame (either Global or a Function)
     void JS2Metadata::defineHoistedVar(Environment *env, const StringAtom &id, StmtNode *p)
     {
@@ -1042,6 +1313,9 @@ namespace MetaData {
     {
         cxt.openNamespaces.clear();
         cxt.openNamespaces.push_back(publicNamespace);
+
+        objectClass = new JS2Class(NULL, new JS2Object(PrototypeInstanceKind), new Namespace(engine->private_StringAtom), true, false, engine->object_StringAtom);
+        objectClass->complete = true;
     }
 
     // objectType(o) returns an OBJECT o's most specific type.
@@ -1062,16 +1336,33 @@ namespace MetaData {
                 return stringClass;
         }
         ASSERT(JS2VAL_IS_OBJECT(obj));
-        return NULL;
-/*
-            NAMESPACE do return namespaceClass;
-            COMPOUNDATTRIBUTE do return attributeClass;
-            CLASS do return classClass;
-            METHODCLOSURE do return functionClass;
-            PROTOTYPE do return prototypeClass;
-            INSTANCE do return resolveAlias(o).type;
-            PACKAGE or GLOBAL do return packageClass
-*/
+        JS2Object *obj = JS2VAL_TO_OBJECT(obj);
+        switch (obj->kind) {
+        case AttributeObjectKind:
+            return attributeClass;
+        case MultinameKind:
+            return namespaceClass;
+        case ClassKind:
+            return classClass;
+        case PrototypeInstanceKind: 
+            return prototypeClass;
+
+        case FixedInstanceKind: 
+            return checked_cast<FixedInstance *>(obj)->type;
+        case DynamicInstanceKind:
+            return checked_cast<DynamicInstance *>(obj)->type;
+
+        case GlobalObjectKind: 
+        case PackageKind:
+            return packageClass;
+
+        case SystemKind:
+        case FunctionKind: 
+        case BlockKind: 
+        default:
+            ASSERT(false);
+            return NULL;
+        }
     }
 
     // Read the property from the container given by the public id in multiname - if that exists
@@ -1216,9 +1507,103 @@ namespace MetaData {
 
     // Read the value of a property in the container. Return true/false if that container has
     // the property or not. If it does, return it's value
-    bool JS2Metadata::readProperty(js2val container, Multiname *multiname, LookupKind *lookupKind, Phase phase, js2val *rval)
+    bool JS2Metadata::readProperty(js2val containerVal, Multiname *multiname, LookupKind *lookupKind, Phase phase, js2val *rval)
     {
-        return true;
+        bool isDynamicInstance = false;
+        if (JS2VAL_IS_PRIMITIVE(containerVal)) {
+readClassProperty:
+            JS2Class *c = objectType(containerVal);
+            InstanceBinding *ib = resolveInstanceMemberName(c, multiname, ReadAccess, Phase phase);
+            if ((ib == NULL) && isDynamicInstance) 
+                return readDynamicProperty(JS2VAL_TO_OBJECT(containerVal), multiname, lookupKind, phase, rval);
+            else 
+                // XXX passing a primitive here ???
+                return readInstanceMember(containerVal, c, (ib)? &ib->qname : NULL, phase, rval);
+        }
+        JS2Object *obj = JS2VAL_TO_OBJECT(containerVal);
+        switch (obj->kind) {
+        case AttributeObjectKind:
+        case MultinameKind:
+        case FixedInstanceKind: 
+            goto readClassProperty;
+        case DynamicInstanceKind:
+            isDynamicInstance = true;
+            goto readClassProperty;
+
+        case SystemKind:
+        case GlobalObjectKind: 
+        case PackageKind:
+        case FunctionKind: 
+        case BlockKind: 
+            {
+            }
+            break;
+        case ClassKind:
+            {
+            }
+            break;
+
+        case PrototypeInstanceKind: 
+            return readDynamicProperty(obj, multiname, lookupKind, phase, rval);
+        default:
+            ASSERT(false);
+            return false;
+        }
+    }
+/*
+m: INSTANCEMEMBEROPT ¨ findInstanceMember(c, qname, read);
+case m of
+{none} do return none;
+INSTANCEVARIABLE do
+if phase = compile and not m.immutable then throw compileExpressionError
+end if;
+v: OBJECTU ¨ findSlot(this, m).value;
+if v = uninitialised then throw uninitialisedError end if;
+return v;
+INSTANCEMETHOD do return METHODCLOSURE·this: this, method: mÒ;
+INSTANCEGETTER do return m.call(this, m.env, phase);
+INSTANCESETTER do
+m cannot be an INSTANCESETTER because these are only represented as write-only members.
+end case
+end proc;
+*/
+
+proc findSlot(o: OBJECT, id: INSTANCEVARIABLE): SLOT
+o must be an INSTANCE;
+matchingSlots: SLOT{} ¨ {s | "s Œ resolveAlias(o).slots such that s.id = id};
+return the one element of matchingSlots
+end proc;
+
+    JS2MetaData::findSlot(js2val thisObjVal, InstanceVariable *id)
+    {
+        ASSERT(JS2VAL_IS_OBJECT(thisObjVal) 
+                    && ((JS2VAL_TO_OBJECT(thisObjVal)->kind == DynamicInstanceKind)
+                        || (JS2VAL_TO_OBJECT(thisObjVal)->kind == FixedInstanceKind)));
+        JS2Object *thisObj = JS2VAL_TO_OBJECT(thisObjVal);
+        Slots *s;
+        if (thisObj->kind == DynamicInstanceKind)
+            s = checked_cast<DynamicInstance *>(thisObj)->slots;
+        else
+            s = checked_cast<FixedInstance *>(thisObj)->slots;
+
+    }
+
+
+    bool JS2Metadata::readInstanceMember(js2val containerVal, JS2Class *c, QualifiedName *qname, Phase phase, js2val *rval)
+    {
+        InstanceMember *m = findInstanceMember(c, qname, ReadAccess);
+        if (m == NULL) return false;
+        switch (m->kind) {
+        case InstanceVariableKind:
+            if ((phase == CompilePhase) && !checked_cast<InstanceVariable *>(m)->immutable)
+                reportError(Exception::compileExpressionError, "Inappropriate compile time expression", engine->errorPos());
+            findSlot(containerVal, m);
+            
+
+        case InstanceMethodKind:
+        case InstanceAccessorKind:
+            break;
+        }
     }
 
     // Read the value of a property in the frame. Return true/false if that frame has
@@ -1444,7 +1829,8 @@ namespace MetaData {
  *
  ************************************************************************************/
 
-    JS2Class::JS2Class(JS2Class *super, JS2Object *proto, Namespace *privateNamespace, bool dynamic, bool final) 
+
+    JS2Class::JS2Class(JS2Class *super, JS2Object *proto, Namespace *privateNamespace, bool dynamic, bool final, const StringAtom &name) 
         : Frame(ClassKind), 
             instanceInitOrder(NULL), 
             complete(false), 
@@ -1455,8 +1841,25 @@ namespace MetaData {
             primitive(false),
             final(final),
             call(NULL),
-            construct(NULL)
-    { }
+            construct(JS2Engine::defaultConstructor),
+            name(name)
+    { 
+    }
+
+    // examine the instancebinding map to determine the number of slots required
+    uint32 JS2Class::countSlots()
+    {
+        uint32 count = 0;
+        InstanceBindingIterator b, end;
+        for (b = instanceReadBindings.begin(), end = instanceReadBindings.end(); (b != end); b++) {
+                
+        }
+        for (b = instanceWriteBindings.begin(), end = instanceWriteBindings.end(); (b != end); b++) {
+        
+        }
+    }
+
+
 
  /************************************************************************************
  *
diff --git a/mozilla/js2/src/js2metadata.h b/mozilla/js2/src/js2metadata.h
index 856aaac4389..02fd9cecd82 100644
--- a/mozilla/js2/src/js2metadata.h
+++ b/mozilla/js2/src/js2metadata.h
@@ -54,7 +54,7 @@ class Pond;
 
 typedef void (Invokable)();
 typedef Invokable Callor;
-typedef JS2Object *(Constructor)();
+typedef JS2Object *(Constructor)(JS2Engine *engine);
 
 enum ObjectKind { 
     AttributeObjectKind, 
@@ -180,8 +180,6 @@ public:
     Multiname(const StringAtom &name) : JS2Object(MultinameKind), name(name) { }
     Multiname(const StringAtom &name, Namespace *ns) : JS2Object(MultinameKind), name(name) { addNamespace(ns); }
 
-    void emitBytecode(BytecodeContainer *bCon, size_t pos)      { bCon->emitOp(eMultiname, pos); bCon->addMultiname(this); }
-
     void addNamespace(Namespace *ns)                { nsList.push_back(ns); }
     void addNamespace(NamespaceList *ns);
     void addNamespace(Context &cxt);
@@ -294,38 +292,64 @@ public:
     StaticMember *content;      // The member to which this qualified name was bound
 };
 
-
 class InstanceMember {
 public:
+    enum InstanceMemberKind { InstanceVariableKind, InstanceMethodKind, InstanceAccessorKind };
+
+    InstanceMember(InstanceMemberKind kind, bool final) : kind(kind), final(final) { }
+
+    InstanceMemberKind kind;
     bool final;             // true if this member may not be overridden in subclasses
+
+#ifdef DEBUG
+    virtual void uselessVirtual()   { } // want the checked_cast stuff to work, so need a virtual function
+#endif
 };
 
 class InstanceVariable : public InstanceMember {
 public:
+    InstanceVariable(bool immutable, bool final) : InstanceMember(InstanceVariableKind, final), immutable(immutable) { }
     JS2Class *type;                 // Type of values that may be stored in this variable
     Invokable *evalInitialValue;    // A function that computes this variable's initial value
     bool immutable;                 // true if this variable's value may not be changed once set
-    bool final;
 };
 
 class InstanceMethod : public InstanceMember {
 public:
+    InstanceMethod() : InstanceMember(InstanceMethodKind, false) { }
     Signature type;         // This method's signature
     Invokable *code;        // This method itself (a callable object); null if this method is abstract
 };
 
 class InstanceAccessor : public InstanceMember {
 public:
+    InstanceAccessor(Invokable *code, bool final) : InstanceMember(InstanceAccessorKind, final), code(code) { }
     JS2Class *type;         // The type of the value read from the getter or written into the setter
     Invokable *code;        // A callable object which does the read or write; null if this method is abstract
 };
 
 class InstanceBinding {
 public:
+    InstanceBinding(QualifiedName &qname, InstanceMember *content) : qname(qname), content(content) { }
+
     QualifiedName qname;         // The qualified name bound by this binding
     InstanceMember *content;     // The member to which this qualified name was bound
 };
 
+// Override status is used to resolve overriden definitions for instance members
+class OverrideStatus {
+public:
+    OverrideStatus(InstanceMember *overriddenMember, const StringAtom &name)
+        : overriddenMember(overriddenMember), potentialConflict(false), multiname(name) { }
+    
+    InstanceMember *overriddenMember;   // NULL for none
+    bool potentialConflict;
+    Multiname multiname;
+};
+typedef std::pair<OverrideStatus *, OverrideStatus *> OverrideStatusPair;
+
+
+
 
 // A StaticBindingMap maps names to a list of StaticBindings. Each StaticBinding in the list
 // will have the same QualifiedName.name, but (potentially) different QualifiedName.namespace values
@@ -353,9 +377,9 @@ public:
 
 class JS2Class : public Frame {
 public:
-    JS2Class(JS2Class *super, JS2Object *proto, Namespace *privateNamespace, bool dynamic, bool final);
+    JS2Class(JS2Class *super, JS2Object *proto, Namespace *privateNamespace, bool dynamic, bool final, const StringAtom &name);
 
-    StringAtom &getName();
+    const StringAtom &getName()                 { return name; }
         
     InstanceBindingMap instanceReadBindings;    // Map of qualified names to readable instance members defined in this class    
     InstanceBindingMap instanceWriteBindings;   // Map of qualified names to writable instance members defined in this class    
@@ -376,6 +400,10 @@ public:
     Callor *call;                               // A procedure to call when this class is used in a call expression
     Constructor *construct;                     // A procedure to call when this class is used in a new expression
 
+    uint32 countSlots();
+
+    const StringAtom &name;
+
 };
 
 class GlobalObject : public Frame {
@@ -397,13 +425,13 @@ public:
 // Instances of non-dynamic classes are represented as FIXEDINSTANCE records. These instances can contain only fixed properties.
 class FixedInstance : public JS2Object {
 public:
-    FixedInstance() : JS2Object(FixedInstanceKind), typeofString(type->getName()) { }
+    FixedInstance(JS2Class *type) : JS2Object(FixedInstanceKind), type(type), call(NULL), construct(NULL), env(NULL), typeofString(type->getName()) { }
 
     JS2Class    *type;          // This instance's type
     Invokable   *call;          // A procedure to call when this instance is used in a call expression
     Invokable   *construct;     // A procedure to call when this instance is used in a new expression
     Environment *env;           // The environment to pass to the call or construct procedure
-    StringAtom  &typeofString;  // A string to return if typeof is invoked on this instance
+    const StringAtom  &typeofString;  // A string to return if typeof is invoked on this instance
     Slot        *slots;         // A set of slots that hold this instance's fixed property values
 };
 
@@ -416,7 +444,7 @@ public:
     Invokable   *call;          // A procedure to call when this instance is used in a call expression
     Invokable   *construct;     // A procedure to call when this instance is used in a new expression
     Environment *env;           // The environment to pass to the call or construct procedure
-    StringAtom  &typeofString;  // A string to return if typeof is invoked on this instance
+    const StringAtom  &typeofString;  // A string to return if typeof is invoked on this instance
     Slot        *slots;         // A set of slots that hold this instance's fixed property values
     DynamicPropertyMap dynamicProperties; // A set of this instance's dynamic properties
 };
@@ -438,7 +466,8 @@ public:
 
 
 // Base class for all references (lvalues)
-// References are generated during the eval stage (bytecode generation)
+// References are generated during the eval stage (bytecode generation), but shouldn't live beyond that
+// XXX use an arena new/delete. (N.B. the contained multinames make it into the bytecode stream)
 class Reference {
 public:
     virtual void emitReadBytecode(BytecodeContainer *bCon, size_t pos)              { ASSERT(false); }
@@ -460,10 +489,9 @@ public:
     Environment *env;               // The environment in which the reference was created.
     bool strict;                    // The strict setting from the context in effect at the point where the reference was created
     
-
-    void emitBindBytecode(BytecodeContainer *bCon, size_t pos)              { variableMultiname->emitBytecode(bCon, pos);  }
-    virtual void emitReadBytecode(BytecodeContainer *bCon, size_t pos)      { bCon->emitOp(eLexicalRead, pos); }
-    virtual void emitWriteBytecode(BytecodeContainer *bCon, size_t pos)     { bCon->emitOp(eLexicalWrite, pos); }
+    
+    virtual void emitReadBytecode(BytecodeContainer *bCon, size_t pos)      { bCon->emitOp(eLexicalRead, pos); bCon->addMultiname(variableMultiname); }
+    virtual void emitWriteBytecode(BytecodeContainer *bCon, size_t pos)     { bCon->emitOp(eLexicalWrite, pos); bCon->addMultiname(variableMultiname); }
 };
 
 class DotReference : public Reference {
@@ -471,13 +499,18 @@ class DotReference : public Reference {
 // object with one of a given set of qualified names. DOTREFERENCE tuples arise from evaluating subexpressions such as a.b or
 // a.q::b.
 public:
-    js2val base;                     // The object whose property was referenced (a in the examples above). The
+    DotReference(const StringAtom &name) : propertyMultiname(new Multiname(name)) { }
+    DotReference(Multiname *mn) : propertyMultiname(mn) { }
+
+    // js2val base;                 // The object whose property was referenced (a in the examples above). The
                                     // object may be a LIMITEDINSTANCE if a is a super expression, in which case
                                     // the property lookup will be restricted to members defined in proper ancestors
                                     // of base.limit.
-    Multiname propertyMultiname;    // A nonempty set of qualified names to which this reference can refer (b
+    Multiname *propertyMultiname;   // A nonempty set of qualified names to which this reference can refer (b
                                     // qualified with the namespace q or all currently open namespaces in the
                                     // example above)
+    virtual void emitReadBytecode(BytecodeContainer *bCon, size_t pos)      { bCon->emitOp(eDotRead, pos); }
+    virtual void emitWriteBytecode(BytecodeContainer *bCon, size_t pos)     { bCon->emitOp(eDotWrite, pos); }
 };
 
 
@@ -646,12 +679,17 @@ public:
 
     void defineHoistedVar(Environment *env, const StringAtom &id, StmtNode *p);
     void defineStaticMember(Environment *env, const StringAtom &id, NamespaceList *namespaces, Attribute::OverrideModifier overrideMod, bool xplicit, Access access, StaticMember *m, size_t pos);
+    OverrideStatusPair defineInstanceMember(JS2Class *c, Context *cxt, const StringAtom &id, NamespaceList *namespaces, Attribute::OverrideModifier overrideMod, bool xplicit, Access access, InstanceMember *m, size_t pos);
+    OverrideStatus *resolveOverrides(JS2Class *c, Context *cxt, const StringAtom &id, NamespaceList *namespaces, Access access, bool expectMethod, size_t pos);
+    OverrideStatus *searchForOverrides(JS2Class *c, const StringAtom &id, NamespaceList *namespaces, Access access, size_t pos);
+    InstanceMember *findInstanceMember(JS2Class *c, QualifiedName *qname, Access access);
 
 
     bool readProperty(js2val container, Multiname *multiname, LookupKind *lookupKind, Phase phase, js2val *rval);
     bool readProperty(Frame *pf, Multiname *multiname, LookupKind *lookupKind, Phase phase, js2val *rval);
     bool readDynamicProperty(JS2Object *container, Multiname *multiname, LookupKind *lookupKind, Phase phase, js2val *rval);
     bool readStaticMember(StaticMember *m, Phase phase, js2val *rval);
+    bool readInstanceMember(js2val containerVal, JS2Class *c, QualifiedName *qname, Phase phase, js2val *rval);
 
 
     bool writeProperty(Frame *container, Multiname *multiname, LookupKind *lookupKind, bool createIfMissing, js2val newValue, Phase phase);
@@ -684,6 +722,9 @@ public:
     JS2Class *objectClass;
     JS2Class *namespaceClass;
     JS2Class *classClass;
+    JS2Class *packageClass;
+    JS2Class *prototypeClass;
+    JS2Class *attributeClass;
 
     Parser *mParser;                // used for error reporting
 
diff --git a/mozilla/js2/src/js2op_access.cpp b/mozilla/js2/src/js2op_access.cpp
index 9da4336c0d9..6236cc77e18 100644
--- a/mozilla/js2/src/js2op_access.cpp
+++ b/mozilla/js2/src/js2op_access.cpp
@@ -31,51 +31,53 @@
 * file under either the NPL or the GPL.
 */
 
-        // Get a multiname literal and add the currently open namespaces from the context
-        // Push the resulting multiname object
-        case eMultiname: 
-            {
-                Multiname *mn = bCon->mMultinameList[BytecodeContainer::getShort(pc)];
-                pc += sizeof(short);
-                mn->addNamespace(meta->cxt);
-                push(OBJECT_TO_JS2VAL(mn));
-            }
-            break;
+    // Get a multiname literal and push the resulting multiname object
+    case eMultiname: 
+        {
+            push(OBJECT_TO_JS2VAL(mn));
+        }
+        break;
 
-        // Pop a multiname object and read it's value from the environment on to the stack.
-        case eLexicalRead: 
-            {
-                js2val mnVal = pop();
-                ASSERT(JS2VAL_IS_OBJECT(mnVal));
-                JS2Object *obj = JS2VAL_TO_OBJECT(mnVal);
-                Multiname *mn = checked_cast<Multiname *>(obj);
-                retval = meta->env.lexicalRead(meta, mn, phase);
-                push(retval);
-	    }
-            break;
+    case eDotRead:
+        {
+            Multiname *mn = bCon->mMultinameList[BytecodeContainer::getShort(pc)];
+            pc += sizeof(short);
+            js2val baseVal = pop();
+            readProperty
+        }
+        break;
 
-        // Pop a value and a multiname. Write the value to the multiname in the environment, leave
-        // the value on the stack top.
-        case eLexicalWrite: 
-            {
-                retval = pop();
-                js2val mnVal = pop();
-                ASSERT(JS2VAL_IS_OBJECT(mnVal));
-                JS2Object *obj = JS2VAL_TO_OBJECT(mnVal);
-                Multiname *mn = checked_cast<Multiname *>(obj);
-                meta->env.lexicalWrite(meta, mn, retval, true, phase);
-                push(retval);
-	    }
-            break;
+    // Pop a multiname object and read it's value from the environment on to the stack.
+    case eLexicalRead: 
+        {
+            Multiname *mn = bCon->mMultinameList[BytecodeContainer::getShort(pc)];
+            pc += sizeof(short);
+            retval = meta->env.lexicalRead(meta, mn, phase);
+            push(retval);
+	}
+        break;
 
-        case ePushFrame: 
-            {
-                Frame *f = bCon->mFrameList[BytecodeContainer::getShort(pc)];
-                pc += sizeof(short);
-            }
-            break;
+    // Pop a value and a multiname. Write the value to the multiname in the environment, leave
+    // the value on the stack top.
+    case eLexicalWrite: 
+        {
+            Multiname *mn = bCon->mMultinameList[BytecodeContainer::getShort(pc)];
+            pc += sizeof(short);
+            meta->env.lexicalWrite(meta, mn, retval, true, phase);
+            push(retval);
+	}
+        break;
 
-        case ePopFrame: 
-            {
-            }
-            break;
\ No newline at end of file
+    case ePushFrame: 
+        {
+            Frame *f = bCon->mFrameList[BytecodeContainer::getShort(pc)];
+            pc += sizeof(short);
+            meta->env.addFrame(f);
+        }
+        break;
+
+    case ePopFrame: 
+        {
+            meta->env.removeTopFrame();
+        }
+        break;
diff --git a/mozilla/js2/src/js2op_arithmetic.cpp b/mozilla/js2/src/js2op_arithmetic.cpp
index f58ca6d713d..5abcc4ec39a 100644
--- a/mozilla/js2/src/js2op_arithmetic.cpp
+++ b/mozilla/js2/src/js2op_arithmetic.cpp
@@ -34,7 +34,8 @@
 
 
 
-        case ePlus: {
+    case eAdd: 
+        {
 	    js2val a = pop();
 	    js2val b = pop();
 	    a = toPrimitive(a);
@@ -55,3 +56,12 @@
         }
         break;
 
+    case eSubtract: 
+        {
+	    js2val a = pop();
+	    js2val b = pop();
+            float64 anum = toNumber(a);
+            float64 bnum = toNumber(b);
+            retval = pushNumber(anum - bnum);
+        }
+        break;
diff --git a/mozilla/js2/src/js2op_flowcontrol.cpp b/mozilla/js2/src/js2op_flowcontrol.cpp
new file mode 100644
index 00000000000..d8ad1935891
--- /dev/null
+++ b/mozilla/js2/src/js2op_flowcontrol.cpp
@@ -0,0 +1,80 @@
+/* -*- 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 or
+* 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.
+*/
+
+    case eReturn: 
+        {
+            retval = pop();
+            return retval;
+	}
+        break;
+
+    case eReturnVoid: 
+        {
+            return retval;
+	}
+        break;
+
+    case eBranchTrue:
+        {
+            retval = pop();
+            ASSERT(JS2VAL_IS_BOOLEAN(retval));
+            bool b = JS2VAL_TO_BOOLEAN(retval);
+            if (b) {
+                int32 offset = BytecodeContainer::getShort(pc);
+                pc += offset;
+            }
+            else 
+                pc += sizeof(int32);
+        }
+        break;
+
+    case eBranchFalse:
+        {
+            retval = pop();
+            ASSERT(JS2VAL_IS_BOOLEAN(retval));
+            bool b = JS2VAL_TO_BOOLEAN(retval);
+            if (!b) {
+                int32 offset = BytecodeContainer::getShort(pc);
+                pc += offset;
+            }
+            else 
+                pc += sizeof(int32);
+        }
+        break;
+
+    case eBranch:
+        {
+            int32 offset = BytecodeContainer::getShort(pc);
+            pc += offset;
+        }
+        break;
diff --git a/mozilla/js2/src/js2op_invocation.cpp b/mozilla/js2/src/js2op_invocation.cpp
index ff0b673dfc8..029257abc22 100644
--- a/mozilla/js2/src/js2op_invocation.cpp
+++ b/mozilla/js2/src/js2op_invocation.cpp
@@ -33,18 +33,8 @@
 */
 
 
-        case eReturn: {
-            retval = pop();
-            return retval;
-	}
-        break;
-
-        case eReturnVoid: {
-            return retval;
-	}
-        break;
-
-        case eNewObject: {
+    case eNewObject: // XXX in js2op_literal instead?
+        {
             uint16 argCount = BytecodeContainer::getShort(pc);
             pc += sizeof(uint16);
             PrototypeInstance *pInst = new PrototypeInstance(NULL); // XXX Object prototype object
@@ -57,6 +47,28 @@
                 const DynamicPropertyMap::value_type e(nameAtom, fieldVal);
                 pInst->dynamicProperties.insert(e);
             }
-            push(OBJECT_TO_JS2VAL(pInst));
+            retval = OBJECT_TO_JS2VAL(pInst);
+            push(retval);
         }
         break;
+
+    case eToBoolean:
+        {
+            js2val v = pop();
+            bool b = toBoolean(v);
+            retval = BOOLEAN_TO_JS2VAL(b);
+            push(retval);
+        }
+        break;
+
+    case eNew:
+        {
+            js2val v = top();
+            ASSERT(JS2VAL_IS_OBJECT(v) && !JS2VAL_IS_NULL(v));
+            JS2Object *obj = JS2VAL_TO_OBJECT(v);
+            ASSERT(obj->kind == ClassKind);
+            JS2Class *c = checked_cast<JS2Class *>(obj);
+            retval = OBJECT_TO_JS2VAL(c->construct(this));
+            push(retval);
+        }
+        break;
\ No newline at end of file