Changeset 38427 in webkit for trunk/JavaScriptCore/parser/Nodes.cpp

Timestamp:

Nov 15, 2008, 1:05:23 PM (17 years ago)

Author:

[email protected]

Message:

2008-11-15 Geoffrey Garen <​[email protected]>

Reviewed by Sam Weinig.

Renames:

CodeGenerator => BytecodeGenerator
emitCodeForBlock => emitBytecodeForBlock
generatedByteCode => generatedBytecode
generateCode => generateBytecode

• JavaScriptCore.exp:
• bytecompiler/CodeGenerator.cpp: (JSC::BytecodeGenerator::setDumpsGeneratedCode): (JSC::BytecodeGenerator::generate): (JSC::BytecodeGenerator::addVar): (JSC::BytecodeGenerator::addGlobalVar): (JSC::BytecodeGenerator::allocateConstants): (JSC::BytecodeGenerator::BytecodeGenerator): (JSC::BytecodeGenerator::addParameter): (JSC::BytecodeGenerator::registerFor): (JSC::BytecodeGenerator::constRegisterFor): (JSC::BytecodeGenerator::isLocal): (JSC::BytecodeGenerator::isLocalConstant): (JSC::BytecodeGenerator::newRegister): (JSC::BytecodeGenerator::newTemporary): (JSC::BytecodeGenerator::highestUsedRegister): (JSC::BytecodeGenerator::newLabelScope): (JSC::BytecodeGenerator::newLabel): (JSC::BytecodeGenerator::emitLabel): (JSC::BytecodeGenerator::emitBytecode): (JSC::BytecodeGenerator::retrieveLastBinaryOp): (JSC::BytecodeGenerator::retrieveLastUnaryOp): (JSC::BytecodeGenerator::rewindBinaryOp): (JSC::BytecodeGenerator::rewindUnaryOp): (JSC::BytecodeGenerator::emitJump): (JSC::BytecodeGenerator::emitJumpIfTrue): (JSC::BytecodeGenerator::emitJumpIfFalse): (JSC::BytecodeGenerator::addConstant): (JSC::BytecodeGenerator::addUnexpectedConstant): (JSC::BytecodeGenerator::addRegExp): (JSC::BytecodeGenerator::emitMove): (JSC::BytecodeGenerator::emitUnaryOp): (JSC::BytecodeGenerator::emitPreInc): (JSC::BytecodeGenerator::emitPreDec): (JSC::BytecodeGenerator::emitPostInc): (JSC::BytecodeGenerator::emitPostDec): (JSC::BytecodeGenerator::emitBinaryOp): (JSC::BytecodeGenerator::emitEqualityOp): (JSC::BytecodeGenerator::emitLoad): (JSC::BytecodeGenerator::emitUnexpectedLoad): (JSC::BytecodeGenerator::findScopedProperty): (JSC::BytecodeGenerator::emitInstanceOf): (JSC::BytecodeGenerator::emitResolve): (JSC::BytecodeGenerator::emitGetScopedVar): (JSC::BytecodeGenerator::emitPutScopedVar): (JSC::BytecodeGenerator::emitResolveBase): (JSC::BytecodeGenerator::emitResolveWithBase): (JSC::BytecodeGenerator::emitResolveFunction): (JSC::BytecodeGenerator::emitGetById): (JSC::BytecodeGenerator::emitPutById): (JSC::BytecodeGenerator::emitPutGetter): (JSC::BytecodeGenerator::emitPutSetter): (JSC::BytecodeGenerator::emitDeleteById): (JSC::BytecodeGenerator::emitGetByVal): (JSC::BytecodeGenerator::emitPutByVal): (JSC::BytecodeGenerator::emitDeleteByVal): (JSC::BytecodeGenerator::emitPutByIndex): (JSC::BytecodeGenerator::emitNewObject): (JSC::BytecodeGenerator::emitNewArray): (JSC::BytecodeGenerator::emitNewFunction): (JSC::BytecodeGenerator::emitNewRegExp): (JSC::BytecodeGenerator::emitNewFunctionExpression): (JSC::BytecodeGenerator::emitCall): (JSC::BytecodeGenerator::emitCallEval): (JSC::BytecodeGenerator::emitReturn): (JSC::BytecodeGenerator::emitUnaryNoDstOp): (JSC::BytecodeGenerator::emitConstruct): (JSC::BytecodeGenerator::emitPushScope): (JSC::BytecodeGenerator::emitPopScope): (JSC::BytecodeGenerator::emitDebugHook): (JSC::BytecodeGenerator::pushFinallyContext): (JSC::BytecodeGenerator::popFinallyContext): (JSC::BytecodeGenerator::breakTarget): (JSC::BytecodeGenerator::continueTarget): (JSC::BytecodeGenerator::emitComplexJumpScopes): (JSC::BytecodeGenerator::emitJumpScopes): (JSC::BytecodeGenerator::emitNextPropertyName): (JSC::BytecodeGenerator::emitCatch): (JSC::BytecodeGenerator::emitNewError): (JSC::BytecodeGenerator::emitJumpSubroutine): (JSC::BytecodeGenerator::emitSubroutineReturn): (JSC::BytecodeGenerator::emitPushNewScope): (JSC::BytecodeGenerator::beginSwitch): (JSC::BytecodeGenerator::endSwitch): (JSC::BytecodeGenerator::emitThrowExpressionTooDeepException):
• bytecompiler/CodeGenerator.h:
• jsc.cpp: (runWithScripts):
• parser/Nodes.cpp: (JSC::ThrowableExpressionData::emitThrowError): (JSC::NullNode::emitBytecode): (JSC::BooleanNode::emitBytecode): (JSC::NumberNode::emitBytecode): (JSC::StringNode::emitBytecode): (JSC::RegExpNode::emitBytecode): (JSC::ThisNode::emitBytecode): (JSC::ResolveNode::isPure): (JSC::ResolveNode::emitBytecode): (JSC::ArrayNode::emitBytecode): (JSC::ObjectLiteralNode::emitBytecode): (JSC::PropertyListNode::emitBytecode): (JSC::BracketAccessorNode::emitBytecode): (JSC::DotAccessorNode::emitBytecode): (JSC::ArgumentListNode::emitBytecode): (JSC::NewExprNode::emitBytecode): (JSC::EvalFunctionCallNode::emitBytecode): (JSC::FunctionCallValueNode::emitBytecode): (JSC::FunctionCallResolveNode::emitBytecode): (JSC::FunctionCallBracketNode::emitBytecode): (JSC::FunctionCallDotNode::emitBytecode): (JSC::emitPreIncOrDec): (JSC::emitPostIncOrDec): (JSC::PostfixResolveNode::emitBytecode): (JSC::PostfixBracketNode::emitBytecode): (JSC::PostfixDotNode::emitBytecode): (JSC::PostfixErrorNode::emitBytecode): (JSC::DeleteResolveNode::emitBytecode): (JSC::DeleteBracketNode::emitBytecode): (JSC::DeleteDotNode::emitBytecode): (JSC::DeleteValueNode::emitBytecode): (JSC::VoidNode::emitBytecode): (JSC::TypeOfResolveNode::emitBytecode): (JSC::TypeOfValueNode::emitBytecode): (JSC::PrefixResolveNode::emitBytecode): (JSC::PrefixBracketNode::emitBytecode): (JSC::PrefixDotNode::emitBytecode): (JSC::PrefixErrorNode::emitBytecode): (JSC::UnaryOpNode::emitBytecode): (JSC::BinaryOpNode::emitBytecode): (JSC::EqualNode::emitBytecode): (JSC::StrictEqualNode::emitBytecode): (JSC::ReverseBinaryOpNode::emitBytecode): (JSC::ThrowableBinaryOpNode::emitBytecode): (JSC::InstanceOfNode::emitBytecode): (JSC::LogicalOpNode::emitBytecode): (JSC::ConditionalNode::emitBytecode): (JSC::emitReadModifyAssignment): (JSC::ReadModifyResolveNode::emitBytecode): (JSC::AssignResolveNode::emitBytecode): (JSC::AssignDotNode::emitBytecode): (JSC::ReadModifyDotNode::emitBytecode): (JSC::AssignErrorNode::emitBytecode): (JSC::AssignBracketNode::emitBytecode): (JSC::ReadModifyBracketNode::emitBytecode): (JSC::CommaNode::emitBytecode): (JSC::ConstDeclNode::emitCodeSingle): (JSC::ConstDeclNode::emitBytecode): (JSC::ConstStatementNode::emitBytecode): (JSC::statementListEmitCode): (JSC::BlockNode::emitBytecode): (JSC::EmptyStatementNode::emitBytecode): (JSC::DebuggerStatementNode::emitBytecode): (JSC::ExprStatementNode::emitBytecode): (JSC::VarStatementNode::emitBytecode): (JSC::IfNode::emitBytecode): (JSC::IfElseNode::emitBytecode): (JSC::DoWhileNode::emitBytecode): (JSC::WhileNode::emitBytecode): (JSC::ForNode::emitBytecode): (JSC::ForInNode::emitBytecode): (JSC::ContinueNode::emitBytecode): (JSC::BreakNode::emitBytecode): (JSC::ReturnNode::emitBytecode): (JSC::WithNode::emitBytecode): (JSC::CaseBlockNode::emitBytecodeForBlock): (JSC::SwitchNode::emitBytecode): (JSC::LabelNode::emitBytecode): (JSC::ThrowNode::emitBytecode): (JSC::TryNode::emitBytecode): (JSC::EvalNode::emitBytecode): (JSC::EvalNode::generateBytecode): (JSC::FunctionBodyNode::generateBytecode): (JSC::FunctionBodyNode::emitBytecode): (JSC::ProgramNode::emitBytecode): (JSC::ProgramNode::generateBytecode): (JSC::FuncDeclNode::emitBytecode): (JSC::FuncExprNode::emitBytecode):
• parser/Nodes.h: (JSC::ExpressionNode::): (JSC::BooleanNode::): (JSC::NumberNode::): (JSC::StringNode::): (JSC::ProgramNode::): (JSC::EvalNode::): (JSC::FunctionBodyNode::):
• runtime/Arguments.h: (JSC::Arguments::getArgumentsData): (JSC::JSActivation::copyRegisters):
• runtime/JSActivation.cpp: (JSC::JSActivation::mark):
• runtime/JSActivation.h: (JSC::JSActivation::JSActivationData::JSActivationData):
• runtime/JSFunction.cpp: (JSC::JSFunction::~JSFunction):

File:

• trunk/JavaScriptCore/parser/Nodes.cpp (modified) (88 diffs)

trunk/JavaScriptCore/parser/Nodes.cpp

@@ -231 +231 @@
 }
 
-RegisterID* ThrowableExpressionData::emitThrowError(CodeGenerator& generator, ErrorType e, const char* msg)
+RegisterID* ThrowableExpressionData::emitThrowError(BytecodeGenerator& generator, ErrorType e, const char* msg)
 {
     generator.emitExpressionInfo(divot(), startOffset(), endOffset());
@@ -239 +239 @@
 }
 
-RegisterID* ThrowableExpressionData::emitThrowError(CodeGenerator& generator, ErrorType e, const char* msg, const Identifier& label)
+RegisterID* ThrowableExpressionData::emitThrowError(BytecodeGenerator& generator, ErrorType e, const char* msg, const Identifier& label)
 {
     UString message = msg;
@@ -275 +275 @@
 // ------------------------------ NullNode -------------------------------------
 
-RegisterID* NullNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* NullNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -284 +284 @@
 // ------------------------------ BooleanNode ----------------------------------
 
-RegisterID* BooleanNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* BooleanNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -293 +293 @@
 // ------------------------------ NumberNode -----------------------------------
 
-RegisterID* NumberNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* NumberNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -302 +302 @@
 // ------------------------------ StringNode -----------------------------------
 
-RegisterID* StringNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* StringNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -311 +311 @@
 // ------------------------------ RegExpNode -----------------------------------
 
-RegisterID* RegExpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* RegExpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegExp> regExp = RegExp::create(generator.globalData(), m_pattern, m_flags);
@@ -323 +323 @@
 // ------------------------------ ThisNode -------------------------------------
 
-RegisterID* ThisNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ThisNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -332 +332 @@
 // ------------------------------ ResolveNode ----------------------------------
 
-bool ResolveNode::isPure(CodeGenerator& generator) const
+bool ResolveNode::isPure(BytecodeGenerator& generator) const
 {
     return generator.isLocal(m_ident);
 }
 
-RegisterID* ResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RegisterID* local = generator.registerFor(m_ident)) {
@@ -374 +374 @@
 }
 
-RegisterID* ArrayNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ArrayNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     // FIXME: Should we put all of this code into emitNewArray?
@@ -429 +429 @@
 }
 
-RegisterID* ObjectLiteralNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ObjectLiteralNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
      if (!m_list) {
@@ -452 +452 @@
 }
 
-RegisterID* PropertyListNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PropertyListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> newObj = generator.tempDestination(dst);
@@ -495 +495 @@
 }
 
-RegisterID* BracketAccessorNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* BracketAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments, m_subscript->isPure(generator));
@@ -515 +515 @@
 }
 
-RegisterID* DotAccessorNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DotAccessorNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RegisterID* base = generator.emitNode(m_base.get());
@@ -535 +535 @@
 }
 
-RegisterID* ArgumentListNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ArgumentListNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     ASSERT(m_expr);
@@ -566 +566 @@
 }
 
-RegisterID* NewExprNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* NewExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
@@ -584 +584 @@
 }
 
-RegisterID* EvalFunctionCallNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* EvalFunctionCallNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> func = generator.tempDestination(dst);
@@ -605 +605 @@
 }
 
-RegisterID* FunctionCallValueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* FunctionCallValueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> func = generator.emitNode(m_expr.get());
@@ -624 +624 @@
 }
 
-RegisterID* FunctionCallResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* FunctionCallResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RefPtr<RegisterID> local = generator.registerFor(m_ident)) {
@@ -662 +662 @@
 }
 
-RegisterID* FunctionCallBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* FunctionCallBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNode(m_base.get());
@@ -685 +685 @@
 }
 
-RegisterID* FunctionCallDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* FunctionCallDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNode(m_base.get());
@@ -696 +696 @@
 // ------------------------------ PostfixResolveNode ----------------------------------
 
-static RegisterID* emitPreIncOrDec(CodeGenerator& generator, RegisterID* srcDst, Operator oper)
+static RegisterID* emitPreIncOrDec(BytecodeGenerator& generator, RegisterID* srcDst, Operator oper)
 {
     return (oper == OpPlusPlus) ? generator.emitPreInc(srcDst) : generator.emitPreDec(srcDst);
 }
 
-static RegisterID* emitPostIncOrDec(CodeGenerator& generator, RegisterID* dst, RegisterID* srcDst, Operator oper)
+static RegisterID* emitPostIncOrDec(BytecodeGenerator& generator, RegisterID* dst, RegisterID* srcDst, Operator oper)
 {
     return (oper == OpPlusPlus) ? generator.emitPostInc(dst, srcDst) : generator.emitPostDec(dst, srcDst);
 }
 
-RegisterID* PostfixResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PostfixResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RegisterID* local = generator.registerFor(m_ident)) {
@@ -763 +763 @@
 }
 
-RegisterID* PostfixBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PostfixBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNode(m_base.get());
@@ -797 +797 @@
 }
 
-RegisterID* PostfixDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PostfixDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNode(m_base.get());
@@ -830 +830 @@
 }
 
-RegisterID* PostfixErrorNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* PostfixErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     return emitThrowError(generator, ReferenceError, m_operator == OpPlusPlus ? "Postfix ++ operator applied to value that is not a reference." : "Postfix -- operator applied to value that is not a reference.");
@@ -837 +837 @@
 // ------------------------------ DeleteResolveNode -----------------------------------
 
-RegisterID* DeleteResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DeleteResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (generator.registerFor(m_ident))
@@ -860 +860 @@
 }
 
-RegisterID* DeleteBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DeleteBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> r0 = generator.emitNode(m_base.get());
@@ -881 +881 @@
 }
 
-RegisterID* DeleteDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DeleteDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RegisterID* r0 = generator.emitNode(m_base.get());
@@ -901 +901 @@
 }
 
-RegisterID* DeleteValueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DeleteValueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     generator.emitNode(ignoredResult(), m_expr.get());
@@ -921 +921 @@
 }
 
-RegisterID* VoidNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* VoidNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult()) {
@@ -933 +933 @@
 // ------------------------------ TypeOfValueNode -----------------------------------
 
-RegisterID* TypeOfResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* TypeOfResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RegisterID* local = generator.registerFor(m_ident)) {
@@ -960 +960 @@
 }
 
-RegisterID* TypeOfValueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* TypeOfValueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult()) {
@@ -972 +972 @@
 // ------------------------------ PrefixResolveNode ----------------------------------
 
-RegisterID* PrefixResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PrefixResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RegisterID* local = generator.registerFor(m_ident)) {
@@ -1017 +1017 @@
 }
 
-RegisterID* PrefixBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PrefixBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNode(m_base.get());
@@ -1046 +1046 @@
 }
 
-RegisterID* PrefixDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* PrefixDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNode(m_base.get());
@@ -1074 +1074 @@
 }
 
-RegisterID* PrefixErrorNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* PrefixErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     return emitThrowError(generator, ReferenceError, m_operator == OpPlusPlus ? "Prefix ++ operator applied to value that is not a reference." : "Prefix -- operator applied to value that is not a reference.");
@@ -1091 +1091 @@
 }
 
-RegisterID* UnaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* UnaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RegisterID* src = generator.emitNode(m_expr.get());
@@ -1110 +1110 @@
 }
 
-RegisterID* BinaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* BinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     BytecodeID bytecode = this->bytecode();
@@ -1125 +1125 @@
 }
 
-RegisterID* EqualNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* EqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (m_expr1->isNull() || m_expr2->isNull()) {
@@ -1137 +1137 @@
 }
 
-RegisterID* StrictEqualNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* StrictEqualNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
@@ -1144 +1144 @@
 }
 
-RegisterID* ReverseBinaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ReverseBinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
@@ -1151 +1151 @@
 }
 
-RegisterID* ThrowableBinaryOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ThrowableBinaryOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
@@ -1159 +1159 @@
 }
 
-RegisterID* InstanceOfNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* InstanceOfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> src1 = generator.emitNodeForLeftHandSide(m_expr1.get(), m_rightHasAssignments, m_expr2->isPure(generator));
@@ -1184 +1184 @@
 }
 
-RegisterID* LogicalOpNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* LogicalOpNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> temp = generator.tempDestination(dst);
@@ -1214 +1214 @@
 }
 
-RegisterID* ConditionalNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ConditionalNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> newDst = generator.finalDestination(dst);
@@ -1246 +1246 @@
 }
 
-// FIXME: should this be moved to be a method on CodeGenerator?
-static ALWAYS_INLINE RegisterID* emitReadModifyAssignment(CodeGenerator& generator, RegisterID* dst, RegisterID* src1, RegisterID* src2, Operator oper, OperandTypes types)
+// FIXME: should this be moved to be a method on BytecodeGenerator?
+static ALWAYS_INLINE RegisterID* emitReadModifyAssignment(BytecodeGenerator& generator, RegisterID* dst, RegisterID* src1, RegisterID* src2, Operator oper, OperandTypes types)
 {
     BytecodeID bytecode;
@@ -1292 +1292 @@
 }
 
-RegisterID* ReadModifyResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ReadModifyResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RegisterID* local = generator.registerFor(m_ident)) {
@@ -1346 +1346 @@
 }
 
-RegisterID* AssignResolveNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* AssignResolveNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (RegisterID* local = generator.registerFor(m_ident)) {
@@ -1388 +1388 @@
 }
 
-RegisterID* AssignDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* AssignDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_rightHasAssignments, m_right->isPure(generator));
@@ -1411 +1411 @@
 }
 
-RegisterID* ReadModifyDotNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ReadModifyDotNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_rightHasAssignments, m_right->isPure(generator));
@@ -1437 +1437 @@
 }
 
-RegisterID* AssignErrorNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* AssignErrorNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     return emitThrowError(generator, ReferenceError, "Left side of assignment is not a reference.");
@@ -1456 +1456 @@
 }
 
-RegisterID* AssignBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* AssignBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments || m_rightHasAssignments, m_subscript->isPure(generator) && m_right->isPure(generator));
@@ -1482 +1482 @@
 }
 
-RegisterID* ReadModifyBracketNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ReadModifyBracketNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> base = generator.emitNodeForLeftHandSide(m_base.get(), m_subscriptHasAssignments || m_rightHasAssignments, m_subscript->isPure(generator) && m_right->isPure(generator));
@@ -1511 +1511 @@
 }
 
-RegisterID* CommaNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* CommaNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     generator.emitNode(ignoredResult(), m_expr1.get());
@@ -1537 +1537 @@
 }
 
-RegisterID* ConstDeclNode::emitCodeSingle(CodeGenerator& generator)
+RegisterID* ConstDeclNode::emitCodeSingle(BytecodeGenerator& generator)
 {
     if (RegisterID* local = generator.constRegisterFor(m_ident)) {
@@ -1553 +1553 @@
 }
 
-RegisterID* ConstDeclNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* ConstDeclNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     RegisterID* result = 0;
@@ -1574 +1574 @@
 }
 
-RegisterID* ConstStatementNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* ConstStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     return generator.emitNode(m_next.get());
@@ -1581 +1581 @@
 // ------------------------------ Helper functions for handling Vectors of StatementNode -------------------------------
 
-static inline RegisterID* statementListEmitCode(const StatementVector& statements, CodeGenerator& generator, RegisterID* dst)
+static inline RegisterID* statementListEmitCode(const StatementVector& statements, BytecodeGenerator& generator, RegisterID* dst)
 {
     StatementVector::const_iterator end = statements.end();
@@ -1614 +1614 @@
 }
 
-RegisterID* BlockNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* BlockNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     return statementListEmitCode(m_children, generator, dst);
@@ -1621 +1621 @@
 // ------------------------------ EmptyStatementNode ---------------------------
 
-RegisterID* EmptyStatementNode::emitBytecode(CodeGenerator&, RegisterID* dst)
+RegisterID* EmptyStatementNode::emitBytecode(BytecodeGenerator&, RegisterID* dst)
 {
     return dst;
@@ -1628 +1628 @@
 // ------------------------------ DebuggerStatementNode ---------------------------
 
-RegisterID* DebuggerStatementNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DebuggerStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     generator.emitDebugHook(DidReachBreakpoint, firstLine(), lastLine());
@@ -1636 +1636 @@
 // ------------------------------ ExprStatementNode ----------------------------
 
-RegisterID* ExprStatementNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ExprStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     ASSERT(m_expr);
@@ -1654 +1654 @@
 }
 
-RegisterID* VarStatementNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* VarStatementNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     ASSERT(m_expr);
@@ -1673 +1673 @@
 }
 
-RegisterID* IfNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* IfNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelID> afterThen = generator.newLabel();
@@ -1703 +1703 @@
 }
 
-RegisterID* IfElseNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* IfElseNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelID> beforeElse = generator.newLabel();
@@ -1743 +1743 @@
 }
 
-RegisterID* DoWhileNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* DoWhileNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
@@ -1779 +1779 @@
 }
 
-RegisterID* WhileNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* WhileNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
@@ -1819 +1819 @@
 }
 
-RegisterID* ForNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ForNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -1897 +1897 @@
 }
 
-RegisterID* ForInNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ForInNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Loop);
@@ -1963 +1963 @@
 
 // ECMA 12.7
-RegisterID* ContinueNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ContinueNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     LabelScope* scope = generator.continueTarget(m_ident);
@@ -1979 +1979 @@
 
 // ECMA 12.8
-RegisterID* BreakNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* BreakNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     LabelScope* scope = generator.breakTarget(m_ident);
@@ -2004 +2004 @@
 }
 
-RegisterID* ReturnNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ReturnNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (generator.codeType() != FunctionCode)
@@ -2034 +2034 @@
 }
 
-RegisterID* WithNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* WithNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<RegisterID> scope = generator.emitNode(m_expr.get()); // scope must be protected until popped
@@ -2160 +2160 @@
 }
 
-RegisterID* CaseBlockNode::emitCodeForBlock(CodeGenerator& generator, RegisterID* switchExpression, RegisterID* dst)
+RegisterID* CaseBlockNode::emitBytecodeForBlock(BytecodeGenerator& generator, RegisterID* switchExpression, RegisterID* dst)
 {
     RefPtr<LabelID> defaultLabel;
@@ -2237 +2237 @@
 }
 
-RegisterID* SwitchNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* SwitchNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelScope> scope = generator.newLabelScope(LabelScope::Switch);
 
     RefPtr<RegisterID> r0 = generator.emitNode(m_expr.get());
-    RegisterID* r1 = m_block->emitCodeForBlock(generator, r0.get(), dst);
+    RegisterID* r1 = m_block->emitBytecodeForBlock(generator, r0.get(), dst);
 
     generator.emitLabel(scope->breakTarget());
@@ -2260 +2260 @@
 }
 
-RegisterID* LabelNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* LabelNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (generator.breakTarget(m_name))
@@ -2284 +2284 @@
 }
 
-RegisterID* ThrowNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* ThrowNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     if (dst == ignoredResult())
@@ -2308 +2308 @@
 }
 
-RegisterID* TryNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* TryNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     RefPtr<LabelID> tryStartLabel = generator.newLabel();
@@ -2414 +2414 @@
 }
 
-RegisterID* EvalNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* EvalNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
@@ -2427 +2427 @@
 }
 
-void EvalNode::generateCode(ScopeChainNode* scopeChainNode)
+void EvalNode::generateBytecode(ScopeChainNode* scopeChainNode)
 {
     ScopeChain scopeChain(scopeChainNode);
@@ -2434 +2434 @@
     m_code.set(new EvalCodeBlock(this, globalObject, source().provider()));
 
-    CodeGenerator generator(this, globalObject->debugger(), scopeChain, &m_code->symbolTable, m_code.get());
+    BytecodeGenerator generator(this, globalObject->debugger(), scopeChain, &m_code->symbolTable, m_code.get());
     generator.generate();
 }
@@ -2493 +2493 @@
 }
 
-void FunctionBodyNode::generateCode(ScopeChainNode* scopeChainNode)
+void FunctionBodyNode::generateBytecode(ScopeChainNode* scopeChainNode)
 {
     ScopeChain scopeChain(scopeChainNode);
@@ -2500 +2500 @@
     m_code.set(new CodeBlock(this, FunctionCode, source().provider(), source().startOffset()));
 
-    CodeGenerator generator(this, globalObject->debugger(), scopeChain, &m_code->symbolTable, m_code.get());
+    BytecodeGenerator generator(this, globalObject->debugger(), scopeChain, &m_code->symbolTable, m_code.get());
     generator.generate();
 }
 
-RegisterID* FunctionBodyNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* FunctionBodyNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     generator.emitDebugHook(DidEnterCallFrame, firstLine(), lastLine());
@@ -2516 +2516 @@
 }
 
-RegisterID* ProgramNode::emitBytecode(CodeGenerator& generator, RegisterID*)
+RegisterID* ProgramNode::emitBytecode(BytecodeGenerator& generator, RegisterID*)
 {
     generator.emitDebugHook(WillExecuteProgram, firstLine(), lastLine());
@@ -2529 +2529 @@
 }
 
-void ProgramNode::generateCode(ScopeChainNode* scopeChainNode)
+void ProgramNode::generateBytecode(ScopeChainNode* scopeChainNode)
 {
     ScopeChain scopeChain(scopeChainNode);
@@ -2536 +2536 @@
     m_code.set(new ProgramCodeBlock(this, GlobalCode, globalObject, source().provider()));
     
-    CodeGenerator generator(this, globalObject->debugger(), scopeChain, &globalObject->symbolTable(), m_code.get(), m_varStack, m_functionStack);
+    BytecodeGenerator generator(this, globalObject->debugger(), scopeChain, &globalObject->symbolTable(), m_code.get(), m_varStack, m_functionStack);
     generator.generate();
 }
@@ -2577 +2577 @@
 }
 
-RegisterID* FuncDeclNode::emitBytecode(CodeGenerator&, RegisterID* dst)
+RegisterID* FuncDeclNode::emitBytecode(BytecodeGenerator&, RegisterID* dst)
 {
     return dst;
@@ -2595 +2595 @@
 }
 
-RegisterID* FuncExprNode::emitBytecode(CodeGenerator& generator, RegisterID* dst)
+RegisterID* FuncExprNode::emitBytecode(BytecodeGenerator& generator, RegisterID* dst)
 {
     return generator.emitNewFunctionExpression(generator.finalDestination(dst), this);