MakeNames: Generate global constants in a loop rather than in sequence.

Source/build/scripts/templates/MakeQualifiedNames.cpp.tmpl

 {% from "macros.tmpl" import license %}
 {{ license() }}
 
 #include "config.h"
 
 #include "{{namespace}}Names.h"
 
 #include "wtf/StaticConstructors.h"
+#include "wtf/StdLibExtras.h"
 
 namespace blink {
 namespace {{namespace}}Names {
 
 using namespace blink;
 
 DEFINE_GLOBAL(AtomicString, {{namespace_prefix}}NamespaceURI)
 
 {% if tags %}
 // Tags
-{% for tag in tags|sort %}
-DEFINE_GLOBAL({{namespace}}QualifiedName, {{tag|symbol}}Tag)
+
+void* {{suffix}}TagStorage[{{namespace}}TagsCount * ((sizeof({{namespace}}QualifiedName) + sizeof(void *) - 1) / sizeof(void *))];
+{% for tag in tags|sort(attribute='name', case_sensitive=True) %}
+const {{namespace}}QualifiedName& {{tag|symbol}}Tag = reinterpret_cast<{{namespace}}QualifiedName*>(&{{suffix}}TagStorage)[{{loop.index0}}];

[Jens Widell, 2014/09/25 17:16:16]

Could you declare an

  const {{namespace}}QualifiedName* const {{namespace}}Tags =
reinterpret_cast<{{namespace}}QualifiedName*>({{namespace}}TagStorage);

and use throughout, to simplify?

[Daniel Bratell, 2014/09/25 17:48:42]

I've tried it but it generates warnings like this:

gen/blink/core/HTMLNames.cpp:33:26: warning: declaration requires a global
constructor [-Wglobal-constructors]
const HTMLQualifiedName& baseTag = Tags[10];


(Actually I had one const less so I tried again with exactly what you wrote
(with one {{namespace}} changed to {{suffix}}) and it still doesn't work.

But it doesn't matter. It collapses to no machine code and it adds one less
symbol to the scope so I can easily pretend I like it this way. :-)

 {% endfor %}
 
 
 PassOwnPtr<const {{namespace}}QualifiedName*[]> get{{namespace}}Tags()
 {
     OwnPtr<const {{namespace}}QualifiedName*[]> tags = adoptArrayPtr(new const {{namespace}}QualifiedName*[{{namespace}}TagsCount]);
-    {% for tag in tags|sort %}
-    tags[{{loop.index0}}] = reinterpret_cast<const {{namespace}}QualifiedName*>(&{{tag|symbol}}Tag);
-    {% endfor %}
+    for (size_t i = 0; i < {{namespace}}TagsCount; i++)
+        tags[i] = reinterpret_cast<{{namespace}}QualifiedName*>(&{{suffix}}TagStorage) + i;
     return tags.release();
 }
 
 {% endif %}
 // Attributes
-{% for attr in attrs|sort %}
-DEFINE_GLOBAL(QualifiedName, {{attr|symbol}}Attr)
+
+void* {{suffix}}AttrStorage[{{namespace}}AttrsCount * ((sizeof(QualifiedName) + sizeof(void *) - 1) / sizeof(void *))];
+
+{% for attr in attrs|sort(attribute='name', case_sensitive=True) %}
+const QualifiedName& {{attr|symbol}}Attr = reinterpret_cast<QualifiedName*>(&{{suffix}}AttrStorage)[{{loop.index0}}];
 {% endfor %}
 
 PassOwnPtr<const QualifiedName*[]> get{{namespace}}Attrs()
 {
     OwnPtr<const QualifiedName*[]> attrs = adoptArrayPtr(new const QualifiedName*[{{namespace}}AttrsCount]);
-    {% for attr in attrs|sort %}
-    attrs[{{loop.index0}}] = reinterpret_cast<const blink::QualifiedName*>(&{{attr|symbol}}Attr);
-    {% endfor %}
+    for (size_t i = 0; i < {{namespace}}AttrsCount; i++)
+        attrs[i] = reinterpret_cast<QualifiedName*>(&{{suffix}}AttrStorage) + i;
     return attrs.release();
 }
 
 void init()
 {
+    struct NameEntry {
+        const char* name;
+        unsigned hash;
+        unsigned char length;
+        unsigned char isTag;
+        unsigned char isAttr;
+    };
+
     // Use placement new to initialize the globals.
     AtomicString {{namespace_prefix}}NS("{{namespace_uri}}", AtomicString::ConstructFromLiteral);
 
     // Namespace
     new ((void*)&{{namespace_prefix}}NamespaceURI) AtomicString({{namespace_prefix}}NS);
-    {% for name, tag_list in (tags + attrs)|groupby('name')|sort %}
-    StringImpl* {{tag_list[0]|symbol}}Impl = StringImpl::createStatic("{{name}}", {{name|length}}, {{name|hash}});
+    {% set tagnames = tags|map(attribute='name')|list() %}
+    {% set attrnames = attrs|map(attribute='name')|list() %}
+    static const NameEntry kNames[] = {
+    {% for name, tag_list in (tags + attrs)|groupby('name')|sort(attribute=0, case_sensitive=True) %}
+        { "{{name}}", {{name|hash}}, {{name|length}}, {{ (name in tagnames)|int }}, {{ (name in attrnames)|int }} },
     {% endfor %}
+    };
 
-    // Tags
-    {% for tag in tags|sort %}
-    QualifiedName::createStatic((void*)&{{tag|symbol}}Tag, {{tag|symbol}}Impl, {{namespace_prefix}}NS);
-    {% endfor %}
+    {% if tags %}
+    size_t tag_i = 0;
+    {% endif %}
+    size_t attr_i = 0;
+    for (size_t i = 0; i < WTF_ARRAY_LENGTH(kNames); i++) {
+        StringImpl* stringImpl = StringImpl::createStatic(kNames[i].name, kNames[i].length, kNames[i].hash);
+        {% if tags %}
+        if (kNames[i].isTag) {
+            void* address = reinterpret_cast<{{namespace}}QualifiedName*>(&{{suffix}}TagStorage) + tag_i;
+            QualifiedName::createStatic(address, stringImpl, {{namespace_prefix}}NS);
+            tag_i++;
+        }
 
-    // Attrs
-    {% for attr in attrs|sort %}
-    {% if use_namespace_for_attrs %}
-    QualifiedName::createStatic((void*)&{{attr|symbol}}Attr, {{attr|symbol}}Impl, {{namespace_prefix}}NS);
-    {% else %}
-    QualifiedName::createStatic((void*)&{{attr|symbol}}Attr, {{attr|symbol}}Impl);
+        if (!kNames[i].isAttr)
+            continue;
+        {% endif %}
+        void* address = reinterpret_cast<QualifiedName*>(&{{suffix}}AttrStorage) + attr_i;
+        {% if use_namespace_for_attrs %}
+        QualifiedName::createStatic(address, stringImpl, {{namespace_prefix}}NS);
+        {% else %}
+        QualifiedName::createStatic(address, stringImpl);
+        {% endif %}
+        attr_i++;
+    }
+    {% if tags %}
+    ASSERT(tag_i == {{namespace}}TagsCount);
     {% endif %}
-    {% endfor %}
+    ASSERT(attr_i == {{namespace}}AttrsCount);
 }
 
 } // {{namespace}}
 } // namespace blink