static bool ReportV8Dead(const char* location) {
FatalErrorCallback callback = GetFatalErrorHandler();
- callback(location, "V8 is no longer useable");
+ callback(location, "V8 is no longer usable");
return true;
}
/**
- * IsDeadCheck checks that the vm is useable. If, for instance, the vm has been
+ * IsDeadCheck checks that the vm is usable. If, for instance, the vm has been
* out of memory at some point this check will fail. It should be called on
* entry to all methods that touch anything in the heap, except destructors
* which you sometimes can't avoid calling after the vm has crashed. Functions
}
// Write the position if it is different from what was written last time and
- // also diferent from the written statement position.
+ // also different from the written statement position.
if (current_position_ != written_position_ &&
current_position_ != written_statement_position_) {
CheckBuffer();
// GetCode emits any pending (non-emitted) code and fills the descriptor
// desc. GetCode() is idempotent; it returns the same result if no other
- // Assembler functions are invoked inbetween GetCode() calls.
+ // Assembler functions are invoked in between GetCode() calls.
void GetCode(CodeDesc* desc);
// Label operations & relative jumps (PPUM Appendix D)
}
// Write the position if it is different from what was written last time and
- // also diferent from the written statement position.
+ // also different from the written statement position.
if (current_position_ != written_position_ &&
current_position_ != written_statement_position_) {
EnsureSpace ensure_space(this);
// GetCode emits any pending (non-emitted) code and fills the descriptor
// desc. GetCode() is idempotent; it returns the same result if no other
- // Assembler functions are invoked inbetween GetCode() calls.
+ // Assembler functions are invoked in between GetCode() calls.
void GetCode(CodeDesc* desc);
// Read/Modify the code target in the branch/call instruction at pc.
// in the sense that some operations (e.g. mov()) can be called in more
// the one way to generate the same instruction: The Register argument
// can in some cases be replaced with an Operand(Register) argument.
- // This should be cleaned up and made more othogonal. The questions
+ // This should be cleaned up and made more orthogonal. The questions
// is: should we always use Operands instead of Registers where an
// Operand is possible, or should we have a Register (overloaded) form
- // instead? We must be carefull to make sure that the selected instruction
+ // instead? We must be careful to make sure that the selected instruction
// is obvious from the parameters to avoid hard-to-find code generation
// bugs.
call->shared()->DontAdaptArguments();
ASSERT(call->is_compiled());
- // Set the expected paramters for apply to 2; required by builtin.
+ // Set the expected parameters for apply to 2; required by builtin.
apply->shared()->set_formal_parameter_count(2);
// Set the lengths for the functions to satisfy ECMA-262.
v8::Handle<v8::ObjectTemplate> global_template,
v8::ExtensionConfiguration* extensions) {
// Link this genesis object into the stacked genesis chain. This
- // must be done before any early exits because the deconstructor
+ // must be done before any early exits because the destructor
// will always do unlinking.
previous_ = current_;
current_ = this;
// Detach the environment from its outer global object.
static void DetachGlobal(Handle<Context> env);
- // Traverses the pointers for memory manangment.
+ // Traverses the pointers for memory management.
static void Iterate(ObjectVisitor* v);
// Accessors for the native scripts cache. Used in lazy loading.
// Append code that needs fixup at the end of boot strapping.
static void AddFixup(Code* code, MacroAssembler* masm);
- // Tells whether boostrapping is active.
+ // Tells whether bootstrapping is active.
static bool IsActive();
// Encoding/decoding support for fixup flags.
__ cmp(r2, Operand(SharedFunctionInfo::kDontAdaptArgumentsSentinel));
__ b(eq, &dont_adapt_arguments);
- { // Enough parameters: actual >= excpected
+ { // Enough parameters: actual >= expected
__ bind(&enough);
EnterArgumentsAdaptorFrame(masm);
// There are incompatibilities between different versions and different
-// implementations of readline. This smoothes out one known incompatibility.
+// implementations of readline. This smooths out one known incompatibility.
#if RL_READLINE_VERSION >= 0x0500
#define completion_matches rl_completion_matches
#endif
static Handle<DebugInfo> GetDebugInfo(Handle<SharedFunctionInfo> shared);
static bool HasDebugInfo(Handle<SharedFunctionInfo> shared);
- // Returns whether the operation succedded.
+ // Returns whether the operation succeeded.
static bool EnsureDebugInfo(Handle<SharedFunctionInfo> shared);
static bool IsDebugBreak(Address addr);
static void ActivateStepIn(StackFrame* frame);
static void ClearStepIn();
static void ClearStepNext();
- // Returns whether the compile succedded.
+ // Returns whether the compile succeeded.
static bool EnsureCompiled(Handle<SharedFunctionInfo> shared);
static void RemoveDebugInfo(Handle<DebugInfo> debug_info);
static void SetAfterBreakTarget(JavaScriptFrame* frame);
Handle<MapCache> new_cache = NewMapCache(24);
context->set_map_cache(*new_cache);
}
- // Check to see whether there is a maching element in the cache.
+ // Check to see whether there is a matching element in the cache.
Handle<MapCache> cache =
Handle<MapCache>(MapCache::cast(context->map_cache()));
Handle<Object> result = Handle<Object>(cache->Lookup(*keys));
Handle<JSObject> extension,
bool is_catch_context);
- // Return the Symbol maching the passed in string.
+ // Return the Symbol matching the passed in string.
static Handle<String> SymbolFromString(Handle<String> value);
// Allocate a new struct. The struct is pretenured (allocated directly in
// Installs interceptors on the instance. 'desc' is a function template,
// and instance is an object instance created by the function of this
- // function tempalte.
+ // function template.
static void ConfigureInstance(Handle<FunctionTemplateInfo> desc,
Handle<JSObject> instance,
bool* pending_exception);
virtual Code* FindCode() const;
- // Garbage colletion support.
+ // Garbage collection support.
virtual void Iterate(ObjectVisitor* v) const;
static ExitFrame* cast(StackFrame* frame) {
// frame below it on the stack.
inline bool has_adapted_arguments() const;
- // Garbage colletion support.
+ // Garbage collection support.
virtual void Iterate(ObjectVisitor* v) const;
// Printing support.
public:
virtual Type type() const { return INTERNAL; }
- // Garbage colletion support.
+ // Garbage collection support.
virtual void Iterate(ObjectVisitor* v) const;
// Determine the code for the frame.
// Handle operations.
// They might invoke garbage collection. The result is an handle to
// an object of expected type, or the handle is an error if running out
-// of space or encounting an internal error.
+// of space or encountering an internal error.
void NormalizeProperties(Handle<JSObject> object,
PropertyNormalizationMode mode);
~HashMap();
- // HashMap entries are (key, value, hash) tripplets.
+ // HashMap entries are (key, value, hash) triplets.
// Some clients may not need to use the value slot
// (e.g. implementers of sets, where the key is the value).
struct Entry {
if (clone->IsFailure()) return clone;
ASSERT(Heap::InNewSpace(clone));
// Since we know the clone is allocated in new space, we can copy
- // the contents without worring about updating the write barrier.
+ // the contents without worrying about updating the write barrier.
CopyBlock(reinterpret_cast<Object**>(HeapObject::cast(clone)->address()),
reinterpret_cast<Object**>(source->address()),
object_size);
static void TracePathToGlobal();
#endif
- // Callback function pased to Heap::Iterate etc. Copies an object if
+ // Callback function passed to Heap::Iterate etc. Copies an object if
// necessary, the object might be promoted to an old space. The caller must
// ensure the precondition that the object is (a) a heap object and (b) in
// the heap's from space.
// Check the key against the length in the array, compute the
// address to store into and fall through to fast case.
- __ ldr(r1, MemOperand(sp)); // resotre key
+ __ ldr(r1, MemOperand(sp)); // restore key
// r0 == value, r1 == key, r2 == elements, r3 == object.
__ ldr(ip, FieldMemOperand(r3, JSArray::kLengthOffset));
__ cmp(r1, Operand(ip));
// normally would be.
Address addr = pc() - Assembler::kTargetAddrToReturnAddrDist;
// Return the address in the original code. This is the place where
- // the call which has been overwriten by the DebugBreakXXX resides
+ // the call which has been overwritten by the DebugBreakXXX resides
// and the place where the inline cache system should look.
int delta = original_code->instruction_start() - code->instruction_start();
return addr + delta;
FixedArray* new_storage = FixedArray::cast(result);
new_storage->set(old_storage->length(), value);
- // Set the new property value and do the map tranistion.
+ // Set the new property value and do the map transition.
object->set_properties(new_storage);
object->set_map(transition);
// This is called as we come into a loop choice node and some other tricky
-// nodes. It normalises the state of the code generator to ensure we can
+// nodes. It normalizes the state of the code generator to ensure we can
// generate generic code.
bool Trace::Flush(RegExpCompiler* compiler, RegExpNode* successor) {
RegExpMacroAssembler* assembler = compiler->macro_assembler();
// Returns a clone of this node initialized using the copy constructor
// of its concrete class. Note that the node may have to be pre-
- // processed before it is on a useable state.
+ // processed before it is on a usable state.
virtual RegExpNode* Clone() = 0;
private:
// We want to pass the msg string like a smi to avoid GC
// problems, however msg is not guaranteed to be aligned
// properly. Instead, we pass an aligned pointer that is
- // a proper v8 smi, but also pass the aligment difference
+ // a proper v8 smi, but also pass the alignment difference
// from the real pointer as a smi.
intptr_t p1 = reinterpret_cast<intptr_t>(msg);
intptr_t p0 = (p1 & ~kSmiTagMask) + kSmiTag;
// We want to pass the msg string like a smi to avoid GC
// problems, however msg is not guaranteed to be aligned
// properly. Instead, we pass an aligned pointer that is
- // a proper v8 smi, but also pass the aligment difference
+ // a proper v8 smi, but also pass the alignment difference
// from the real pointer as a smi.
intptr_t p1 = reinterpret_cast<intptr_t>(msg);
intptr_t p0 = (p1 & ~kSmiTagMask) + kSmiTag;
CodePatcher::CodePatcher(byte* address, int size)
: address_(address), size_(size), masm_(address, size + Assembler::kGap) {
- // Create a new macro assembler pointing to the assress of the code to patch.
+ // Create a new macro assembler pointing to the address of the code to patch.
// The size is adjusted with kGap on order for the assembler to generate size
// bytes of instructions without failing with buffer size constraints.
ASSERT(masm_.reloc_info_writer.pos() == address_ + size_ + Assembler::kGap);
//
// Review notes:
//
-// - The use of macros in these inline fuctions may seem superfluous
+// - The use of macros in these inline functions may seem superfluous
// but it is absolutely needed to make sure gcc generates optimal
// code. gcc is not happy when attempting to inline too deep.
//
}
new_map->set_unused_property_fields(0);
- // We have now sucessfully allocated all the necessary objects.
+ // We have now successfully allocated all the necessary objects.
// Changes can now be made with the guarantee that all of them take effect.
set_map(new_map);
map()->set_instance_descriptors(Heap::empty_descriptor_array());
// callback overwriting in this object or it's prototype chain.
// This mechanism is needed for instance in a browser setting, where
// certain accessors such as window.location should not be allowed
- // to be overwriten because allowing overwriting could potentially
+ // to be overwritten because allowing overwriting could potentially
// cause security problems.
LookupResult callback_result;
LookupCallback(name, &callback_result);
int BinarySearch(String* name, int low, int high);
// Perform a linear search in the instance descriptors represented
- // by this fixed array. len is the number of descriptor indeces that are
+ // by this fixed array. len is the number of descriptor indices that are
// valid. Does not require the descriptors to be sorted.
int LinearSearch(String* name, int len);
// Returns the key at entry.
Object* KeyAt(int entry) { return get(EntryToIndex(entry)); }
- // Tells wheter k is a real key. Null and undefined are not allowed
+ // Tells whether k is a real key. Null and undefined are not allowed
// as keys and can be used to indicate missing or deleted elements.
bool IsKey(Object* k) {
return !k->IsNull() && !k->IsUndefined();
void UpdateMaxNumberKey(uint32_t key);
- // Generate new enumneration indices to avoid enumeration insdex overflow.
+ // Generate new enumeration indices to avoid enumeration index overflow.
Object* GenerateNewEnumerationIndices();
static const int kMaxNumberKeyIndex = kPrefixStartIndex;
// Returns true if pc is inside this object's instructions.
inline bool contains(byte* pc);
- // Returns the adddress of the scope information.
+ // Returns the address of the scope information.
inline byte* sinfo_start();
// Convert inline cache target from address to code object before GC.
};
-// An accesor must have a getter, but can have no setter.
+// An accessor must have a getter, but can have no setter.
//
// When setting a property, V8 searches accessors in prototypes.
// If an accessor was found and it does not have a setter,
};
-// The DebugInfo class holds additional information for a function beeing
+// The DebugInfo class holds additional information for a function being
// debugged.
class DebugInfo: public Struct {
public:
- // The shared function info for the source beeing debugged.
+ // The shared function info for the source being debugged.
DECL_ACCESSORS(shared, SharedFunctionInfo)
// Code object for the original code.
DECL_ACCESSORS(original_code, Code)
// Allocation macro that should be used to allocate objects that must
// only be allocated in real parsing mode. Note that in preparse mode
// not only is the syntax tree not created but the constructor
-// arguments are not evaulated.
+// arguments are not evaluated.
#define NEW(expr) (is_pre_parsing_ ? NULL : new expr)
// statements, which themselves are only valid within blocks,
// iterations or 'switch' statements (i.e., BreakableStatements),
// labels can be simply ignored in all other cases; except for
- // trivial labelled break statements 'label: break label' which is
+ // trivial labeled break statements 'label: break label' which is
// parsed into an empty statement.
// Keep the source position of the statement
tok != Token::SEMICOLON && tok != Token::RBRACE && tok != Token::EOS) {
label = ParseIdentifier(CHECK_OK);
}
- // Parse labelled break statements that target themselves into
+ // Parse labeled break statements that target themselves into
// empty statements, e.g. 'l1: l2: l3: break l2;'
if (!label.is_null() && ContainsLabel(labels, label)) {
return factory()->EmptyStatement();
// Support for doing lazy compilation. The script is the script containing full
// source of the script where the function is declared. The start_position and
// end_position specifies the part of the script source which has the source
-// for the function decleration in the form:
+// for the function declaration in the form:
//
// (<formal parameters>) { <function body> }
//
}
-void OS::Sleep(int miliseconds) {
- usleep(1000 * miliseconds);
+void OS::Sleep(int milliseconds) {
+ usleep(1000 * milliseconds);
}
#include <dbghelp.h> // For SymLoadModule64 and al.
#include <tlhelp32.h> // For Module32First and al.
-// These aditional WIN32 includes have to be right here as the #undef's below
+// These additional WIN32 includes have to be right here as the #undef's below
// makes it impossible to have them elsewhere.
#include <winsock2.h>
#include <process.h> // for _beginthreadex()
}
-// Return the dalight savings time offset for this time.
+// Return the daylight savings time offset for this time.
int64_t Time::DaylightSavingsOffset() {
return InDST() ? 60 * kMsPerMinute : 0;
}
// The following code loads functions defined in DbhHelp.h and TlHelp32.h
-// dynamically. This is to avoid beeing depending on dbghelp.dll and
+// dynamically. This is to avoid being depending on dbghelp.dll and
// tlhelp32.dll when running (the functions in tlhelp32.dll have been moved to
// kernel32.dll at some point so loading functions defines in TlHelp32.h
// dynamically might not be necessary any more - for some versions of Windows?).
dbghelp_loaded = result;
return result;
- // NOTE: The modules are never unloaded and will stay arround until the
+ // NOTE: The modules are never unloaded and will stay around until the
// application is closed.
}
// implementation for a particular platform is put in platform_<os>.cc.
// The build system then uses the implementation for the target platform.
//
-// This design has been choosen because it is simple and fast. Alternatively,
+// This design has been chosen because it is simple and fast. Alternatively,
// the platform dependent classes could have been implemented using abstract
// superclasses with virtual methods and having specializations for each
// platform. This design was rejected because it was more complicated and
static void PrintError(const char* format, ...);
static void VPrintError(const char* format, va_list args);
- // Allocate/Free memory used by JS heap. Pages are readable/writeable, but
+ // Allocate/Free memory used by JS heap. Pages are readable/writable, but
// they are not guaranteed to be executable unless 'executable' is true.
// Returns the address of allocated memory, or NULL if failed.
static void* Allocate(const size_t requested,
// heap corruption.
static bool IsOutsideAllocatedSpace(void* pointer);
- // Sleep for a number of miliseconds.
- static void Sleep(const int miliseconds);
+ // Sleep for a number of milliseconds.
+ static void Sleep(const int milliseconds);
// Abort the current process.
static void Abort();
protected:
DescriptorArray* descriptors_;
int pos_; // Current position.
- int limit_; // Limit for posistion.
+ int limit_; // Limit for position.
};
__ pop(ebx);
__ pop(edi);
__ pop(esi);
- // Exit function frame, restore previus one.
+ // Exit function frame, restore previous one.
__ pop(ebp);
__ ret(0);
case Token::INIT_VAR:
case Token::INIT_CONST:
case Token::ASSIGN:
- // Pure assigment copies the type from the value.
+ // Pure assignment copies the type from the value.
node->type()->CopyFrom(node->value()->type());
break;
case Token::ASSIGN_BIT_OR:
node->type()->SetAsLikelySmi();
}
if (node->type()->IsLikelySmi()) {
- // The type of this node changed to LIKELY_SMI. Propagate this knowlege
+ // The type of this node changed to LIKELY_SMI. Propagate this knowledge
// down through the nodes.
if (node->left()->type()->IsUnknown()) {
node->left()->type()->SetAsLikelySmi();
node->type()->SetAsLikelySmi();
}
if (node->type()->IsLikelySmi()) {
- // The type of this node changed to LIKELY_SMI. Propagate this knowlege
+ // The type of this node changed to LIKELY_SMI. Propagate this knowledge
// down through the nodes.
if (node->left()->type()->IsUnknown()) {
node->left()->type()->SetAsLikelySmi();
&is_result_from_cache);
Handle<JSObject> boilerplate = Factory::NewJSObjectFromMap(map);
- { // Add the constant propeties to the boilerplate.
+ { // Add the constant properties to the boilerplate.
int length = constant_properties->length();
OptimizedObjectForAddingMultipleProperties opt(boilerplate,
!is_result_from_cache);
name = Handle<String>::cast(converted);
}
- // Check if the name is trivially convertable to an index and get
+ // Check if the name is trivially convertible to an index and get
// the element if so.
if (name->AsArrayIndex(&index)) {
return GetElementOrCharAt(object, index);
// itself.
//
// The global proxy objects has to be excluded since LocalLookup on
- // the global proxy object can return a valid result eventhough the
+ // the global proxy object can return a valid result even though the
// global proxy object never has properties. This is the case
// because the global proxy object forwards everything to its hidden
// prototype including local lookups.
// same as the lexicographic order of the string representations.
if (x_value == 0 || y_value == 0) return Smi::FromInt(x_value - y_value);
- // If only one of the intergers is negative the negative number is
+ // If only one of the integers is negative the negative number is
// smallest because the char code of '-' is less than the char code
// of any digit. Otherwise, we make both values positive.
if (x_value < 0 || y_value < 0) {
if (constructor->IsJSFunction()) {
JSFunction* function = JSFunction::cast(constructor);
- // Handle steping into constructors if step into is active.
+ // Handle stepping into constructors if step into is active.
if (Debug::StepInActive()) {
HandleScope scope;
Debug::HandleStepIn(Handle<JSFunction>(function), 0, true);
case CONSTANT_FUNCTION:
return obj->GetProperty(name);
case CALLBACKS: {
- // Get the property value. If there is an exception it must be thown from
+ // Get the property value. If there is an exception it must be thrown from
// a JavaScript getter.
Object* value;
value = obj->GetProperty(name);
}
if (start_position <= position &&
position <= shared->end_position()) {
- // If there is no candidate or this function is within the currrent
+ // If there is no candidate or this function is within the current
// candidate this is the new candidate.
if (target.is_null()) {
target_start_position = start_position;
// Evaluate a piece of JavaScript in the context of a stack frame for
-// debugging. This is acomplished by creating a new context which in its
+// debugging. This is accomplished by creating a new context which in its
// extension part has all the parameters and locals of the function on the
// stack frame. A function which calls eval with the code to evaluate is then
// compiled in this context and called in this context. As this context
// Wrap the evaluation statement in a new function compiled in the newly
// created context. The function has one parameter which has to be called
// 'arguments'. This it to have access to what would have been 'arguments' in
- // the function beeing debugged.
+ // the function being debugged.
// function(arguments,__source__) {return eval(__source__);}
static const char* source_str =
"function(arguments,__source__){return eval(__source__);}";
ASSERT(args.length() == 0);
// Perform two GCs to get rid of all unreferenced scripts. The first GC gets
- // rid of all the cached script wrappes and the second gets rid of the
+ // rid of all the cached script wrappers and the second gets rid of the
// scripts which is no longer referenced.
Heap::CollectAllGarbage();
Heap::CollectAllGarbage();
bool Scanner::IsIdentifier(unibrow::CharacterStream* buffer) {
- // Checks whether the buffer contains an identifier (no escapse).
+ // Checks whether the buffer contains an identifier (no escape).
if (!buffer->has_more()) return false;
if (!kIsIdentifierStart.get(buffer->GetNext())) return false;
while (buffer->has_more()) {
// This lookup corresponds to a lookup in the "intermediate" scope sitting
// between this scope and the outer scope. (ECMA-262, 3rd., requires that
// the name of named function literal is kept in an intermediate scope
- // inbetween this scope and the next outer scope.)
+ // in between this scope and the next outer scope.)
if (function_ != NULL && function_->name().is_identical_to(name)) {
var = function_;
private:
char* str_; // the snapshot
- int len_; // the curent length of str_
+ int len_; // the current length of str_
int max_; // the allocated size of str_
};
virtual ~Deserializer();
// Read the flags from the header of the file, and set those that
- // should be inhereted from the snapshot.
+ // should be inherited from the snapshot.
void GetFlags();
// Read saved profiling information from the file and log it if required.
using ::v8::internal::DeleteArray;
// This macro provides a platform independent use of sscanf. The reason for
-// SScanF not beeing implemented in a platform independent was through
+// SScanF not being implemented in a platform independent was through
// ::v8::internal::OS in the same way as SNPrintF is that the Windows C Run-Time
// Library does not provide vsscanf.
#define SScanF sscanf // NOLINT
void Execute();
// V8 generally calls into generated code with 5 parameters. This is a
- // convenience funtion, which sets up the simulator state and grabs the
+ // convenience function, which sets up the simulator state and grabs the
// result on return.
v8::internal::Object* Call(int32_t entry, int32_t p0, int32_t p1,
int32_t p2, int32_t p3, int32_t p4);
// Expands the space by allocating a fixed number of pages. Returns false if
// it cannot allocate requested number of pages from OS. Newly allocated
- // pages are appened to the last_page;
+ // pages are append to the last_page;
bool Expand(Page* last_page);
// Generic fast case allocation function that tries linear allocation in
// Double the size of the semispace by committing extra virtual memory.
// Assumes that the caller has checked that the semispace has not reached
- // its maxmimum capacity (and thus there is space available in the reserved
+ // its maximum capacity (and thus there is space available in the reserved
// address range to grow).
bool Double();
return (reinterpret_cast<uint32_t>(o) & object_mask_) == object_expected_;
}
- // The offset of an address from the begining of the space.
+ // The offset of an address from the beginning of the space.
int SpaceOffsetForAddress(Address addr) { return addr - low(); }
// If we don't have this here then SemiSpace will be abstract. However
// Returns the object in this chunk.
inline HeapObject* GetObject();
- // Given a requested size (including any extra remembereed set words),
+ // Given a requested size (including any extra remembered set words),
// returns the physical size of a chunk to be allocated.
static int ChunkSizeFor(int size_in_bytes);
- // Given a chunk size, returns the object size it can accomodate (not
+ // Given a chunk size, returns the object size it can accommodate (not
// including any extra remembered set words). Used by
// LargeObjectSpace::Available. Note that this can overestimate the size
// of object that will fit in a chunk---if the object requires extra
// Perform map transition for the receiver if necessary.
if ((transition != NULL) && (object->map()->unused_property_fields() == 0)) {
// The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the propeties array.
+ // We jump to a runtime call that extends the properties array.
__ mov(r2, Operand(Handle<Map>(transition)));
// Please note, if we implement keyed store for arm we need
// to call the Builtins::KeyedStoreIC_ExtendStorage.
// Perform map transition for the receiver if necessary.
if ((transition != NULL) && (object->map()->unused_property_fields() == 0)) {
// The properties must be extended before we can store the value.
- // We jump to a runtime call that extends the propeties array.
+ // We jump to a runtime call that extends the properties array.
__ mov(ecx, Immediate(Handle<Map>(transition)));
Handle<Code> ic(Builtins::builtin(storage_extend));
__ jmp(ic, RelocInfo::CODE_TARGET);
Failure* Top::ReThrow(Object* exception, MessageLocation* location) {
- // Set the exception beeing re-thrown.
+ // Set the exception being re-thrown.
set_pending_exception(exception);
return Failure::Exception();
}
Handle<Object> is_top_level = it.done()
? Factory::true_value()
: Factory::false_value();
- // Generate and print strack trace line.
+ // Generate and print stack trace line.
Handle<String> line =
Execution::GetStackTraceLine(recv, fun, pos_obj, is_top_level);
if (line->length() > 0) {
// Top has static variables used for JavaScript execution.
-class SaveContext; // Forward decleration.
+class SaveContext; // Forward declaration.
class ThreadLocalTop BASE_EMBEDDED {
public:
// If the GCC version is 4.1.x or 4.2.x an additional field is added to the
-// class as a workarround for a bug in the generated code found with these
+// class as a work around for a bug in the generated code found with these
// versions of GCC. See V8 issue 122 for details.
class SaveContext BASE_EMBEDDED {
public:
// Simple support to read a file into a 0-terminated C-string.
// The returned buffer must be freed by the caller.
-// On return, *exits tells whether the file exisited.
+// On return, *exits tells whether the file existed.
Vector<const char> ReadFile(const char* filename,
bool* exists,
bool verbose = true);
// Stop sending preemption requests to threads.
static void StopPreemption();
- // Preempted thread needs to call back to the ContextSwitcher to acknowlege
+ // Preempted thread needs to call back to the ContextSwitcher to acknowledge
// the handling of a preemption request.
static void PreemptionReceived();
void* operator new(size_t size) { return Zone::New(size); }
// Ideally, the delete operator should be private instead of
- // public, but unfortuately the compiler sometimes synthesizes
+ // public, but unfortunately the compiler sometimes synthesizes
// (unused) destructors for classes derived from ZoneObject, which
// require the operator to be visible. MSVC requires the delete
// operator to be public.
projects / platform / upstream / v8.git / commitdiff