Add Dart keyword symbols to the VM isolate

runtime/vm/symbols.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/symbols.h"
 
 #include "vm/handles.h"
 #include "vm/handles_impl.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/raw_object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/unicode.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 RawString* Symbols::predefined_[Symbols::kNumberOfOneCharCodeSymbols];
 String* Symbols::symbol_handles_[Symbols::kMaxPredefinedId];
 
 static const char* names[] = {
   NULL,
 
 #define DEFINE_SYMBOL_LITERAL(symbol, literal)                                 \
   literal,
 PREDEFINED_SYMBOLS_LIST(DEFINE_SYMBOL_LITERAL)
 #undef DEFINE_SYMBOL_LITERAL
+
+  "",  // matches kKwTableStart.
+
+#define DEFINE_KEYWORD_SYMBOL_INDEX(token, chars, ignore1, ignore2)            \
+  chars,
+  DART_KEYWORD_LIST(DEFINE_KEYWORD_SYMBOL_INDEX)
+#undef DEFINE_KEYWORD_SYMBOL_INDEX
 };
 
 intptr_t Symbols::num_of_grows_;
 intptr_t Symbols::collision_count_[kMaxCollisionBuckets];
 
 DEFINE_FLAG(bool, dump_symbol_stats, false, "Dump symbol table statistics");
 
 
 const char* Symbols::Name(SymbolId symbol) {
   ASSERT((symbol > kIllegal) && (symbol < kNullCharId));
   return names[symbol];
 }
 
 
+const String& Symbols::Keyword(Token::Kind keyword) {
+  const int kw_index = keyword - Token::kFirstKeyword;
+  ASSERT((0 <= kw_index) && (kw_index < Token::numKeywords));
+  ASSERT(Token::kABSTRACT == Token::kFirstKeyword);
+  const intptr_t keyword_id = Symbols::kABSTRACTId + kw_index;

[Ivan Posva, 2013/11/14 19:37:57]

This should all be based on kKwTableStart if I am not mistaken.

[hausner, 2013/11/14 19:41:43]

Yes. The kABSTRACTId is a left-over from before I had kKwTableStart. Will fix in
a subsequent cl.

+  ASSERT(symbol_handles_[keyword_id] != NULL);
+  return *symbol_handles_[keyword_id];
+}
+
+
 void Symbols::InitOnce(Isolate* isolate) {
   // Should only be run by the vm isolate.
   ASSERT(isolate == Dart::vm_isolate());
 
   if (FLAG_dump_symbol_stats) {
     num_of_grows_ = 0;
     for (intptr_t i = 0; i < kMaxCollisionBuckets; i++) {
       collision_count_[i] = 0;
     }
   }
 
   // Create and setup a symbol table in the vm isolate.
   SetupSymbolTable(isolate);
 
   // Create all predefined symbols.
   ASSERT((sizeof(names) / sizeof(const char*)) == Symbols::kNullCharId);
   ObjectStore* object_store = isolate->object_store();
   Array& symbol_table = Array::Handle();
 
 
   // First set up all the predefined string symbols.
-  for (intptr_t i = 1; i < Symbols::kNullCharId; i++) {
+  for (intptr_t i = 1; i < Symbols::kKwTableStart; i++) {
     // The symbol_table needs to be reloaded as it might have grown in the
     // previous iteration.
     symbol_table = object_store->symbol_table();
     String* str = String::ReadOnlyHandle();
     *str = OneByteString::New(names[i], Heap::kOld);
     Add(symbol_table, *str);
     symbol_handles_[i] = str;
   }
   Object::RegisterSingletonClassNames();
 
+  // Create symbols for language keywords. Some keywords are equal to
+  // symbols we already created, so use New() instead of Add() to ensure
+  // that the symbols are canonicalized.
+  for (intptr_t i = Symbols::kKwTableStart; i < Symbols::kNullCharId; i++) {
+    String* str = String::ReadOnlyHandle();
+    *str = New(names[i]);
+    symbol_handles_[i] = str;
+  }
+
   // Add Latin1 characters as Symbols, so that Symbols::FromCharCode is fast.
   for (intptr_t c = 0; c < kNumberOfOneCharCodeSymbols; c++) {
     // The symbol_table needs to be reloaded as it might have grown in the
     // previous iteration.
     symbol_table = object_store->symbol_table();
     intptr_t idx = (kNullCharId + c);
     ASSERT(idx < kMaxPredefinedId);
     ASSERT(Utf::IsLatin1(c));
     uint8_t ch = static_cast<uint8_t>(c);
     String* str = String::ReadOnlyHandle();
@@ skipping 362 matching lines @@
 RawObject* Symbols::GetVMSymbol(intptr_t object_id) {
   ASSERT(IsVMSymbolId(object_id));
   intptr_t i = (object_id - kMaxPredefinedObjectIds);
   if ((i > kIllegal) && (i < Symbols::kMaxPredefinedId)) {
     return symbol_handles_[i]->raw();
   }
   return Object::null();
 }
 
 }  // namespace dart