Fix a bunch of spelling mistakes :\

src/parser.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 622 matching lines @@
   ZoneList<T*>* elements() { return list_; }
   T* at(int index) { return list_->at(index); }
  private:
   ZoneList<T*>* list_;
 };
 
 
 // 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)
 
 
 class ParserFactory BASE_EMBEDDED {
  public:
   explicit ParserFactory(bool is_pre_parsing) :
       is_pre_parsing_(is_pre_parsing) { }
 
   virtual ~ParserFactory() { }
 
@@ skipping 593 matching lines @@
   //   LabelledStatement
   //   SwitchStatement
   //   ThrowStatement
   //   TryStatement
   //   DebuggerStatement
 
   // Note: Since labels can only be used by 'break' and 'continue'
   // 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
   int statement_pos = scanner().peek_location().beg_pos;
   Statement* stmt = NULL;
   switch (peek()) {
     case Token::LBRACE:
       return ParseBlock(labels, ok);
 
     case Token::CONST:  // fall through
@@ skipping 594 matching lines @@
   // BreakStatement ::
   //   'break' Identifier? ';'
 
   Expect(Token::BREAK, CHECK_OK);
   Handle<String> label;
   Token::Value tok = peek();
   if (!scanner_.has_line_terminator_before_next() &&
       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();
   }
   BreakableStatement* target = NULL;
   if (!is_pre_parsing_) {
     target = LookupBreakTarget(label, CHECK_OK);
     if (target == NULL) {
       // Illegal break statement.  To be consistent with KJS we delay
       // reporting of the syntax error until runtime.
@@ skipping 2495 matching lines @@
                        start_position,
                        is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal