Move char type definitions and magic string processing functions to literal component.

JerryScript-DCO-1.0-Signed-off-by: Andrey Shitov a.shitov@samsung.com
2015-06-29 17:57:10 +03:00
parent 07148d319b
commit a0c5974ab8
88 changed files with 1185 additions and 1091 deletions
@@ -0,0 +1,63 @@
+/* Copyright 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIT_GLOBALS_H
+#define LIT_GLOBALS_H
+
+#include "jrt.h"
+
+#if CONFIG_ECMA_CHAR_ENCODING == CONFIG_ECMA_CHAR_ASCII
+/**
+ * Description of an ecma-character
+ */
+typedef uint8_t ecma_char_t;
+#elif CONFIG_ECMA_CHAR_ENCODING == CONFIG_ECMA_CHAR_UTF16
+/**
+ * Description of an ecma-character
+ */
+typedef uint16_t ecma_char_t;
+#endif /* CONFIG_ECMA_CHAR_ENCODING == CONFIG_ECMA_CHAR_UTF16 */
+
+/**
+ * Description of an ecma-character pointer
+ */
+typedef ecma_char_t *ecma_char_ptr_t;
+
+/**
+ * Null character (zt-string end marker)
+ */
+#define ECMA_CHAR_NULL  ((ecma_char_t) '\0')
+
+/**
+ * Description of a collection's/string's length
+ */
+typedef uint16_t ecma_length_t;
+
+/**
+ * ECMA string hash
+ */
+typedef uint8_t lit_string_hash_t;
+
+/**
+ * Length of string hash, in bits
+ */
+#define LIT_STRING_HASH_BITS (sizeof (lit_string_hash_t) * JERRY_BITSINBYTE)
+
+/**
+ * Number of string's last characters to use for hash calculation
+ */
+#define LIT_STRING_HASH_LAST_BYTES_COUNT (2)
+
+#endif /* LIT_GLOBALS_H */
@@ -256,7 +256,7 @@ lit_literal_storage_t::create_charset_record (const ecma_char_t *str, /**< strin
 * @return  pointer to the created record
 */
 lit_magic_record_t *
-lit_literal_storage_t::create_magic_record (ecma_magic_string_id_t id) /**< id of a magic string */
+lit_literal_storage_t::create_magic_record (lit_magic_string_id_t id) /**< id of a magic string */
 {
  lit_magic_record_t *ret = alloc_record<lit_magic_record_t> (LIT_MAGIC_STR);
  ret->set_magic_str_id (id);
@@ -270,7 +270,7 @@ lit_literal_storage_t::create_magic_record (ecma_magic_string_id_t id) /**< id o
 * @return  pointer to the created record
 */
 lit_magic_record_t *
-lit_literal_storage_t::create_magic_record_ex (ecma_magic_string_ex_id_t id) /**< id of a magic string */
+lit_literal_storage_t::create_magic_record_ex (lit_magic_string_ex_id_t id) /**< id of a magic string */
 {
  lit_magic_record_t *ret = alloc_record<lit_magic_record_t> (LIT_MAGIC_STR_EX);
  ret->set_magic_str_id (id);
@@ -329,16 +329,16 @@ lit_literal_storage_t::dump ()
      }
      case LIT_MAGIC_STR:
      {
-        ecma_magic_string_id_t id = lit_magic_record_get_magic_str_id (rec_p);
-        printf ("%s : MAGIC STRING", ecma_get_magic_string_zt (id));
+        lit_magic_string_id_t id = lit_magic_record_get_magic_str_id (rec_p);
+        printf ("%s : MAGIC STRING", lit_get_magic_string_zt (id));
        printf (" [id=%d] ", id);

        break;
      }
      case LIT_MAGIC_STR_EX:
      {
-        ecma_magic_string_ex_id_t id = lit_magic_record_ex_get_magic_str_id (rec_p);
-        printf ("%s : EXT MAGIC STRING", ecma_get_magic_string_ex_zt (id));
+        lit_magic_string_ex_id_t id = lit_magic_record_ex_get_magic_str_id (rec_p);
+        printf ("%s : EXT MAGIC STRING", lit_get_magic_string_ex_zt (id));
        printf (" [id=%d] ", id);

        break;
@@ -478,10 +478,10 @@ template ecma_number_t rcs_record_iterator_t::read<ecma_number_t> ();
 template void rcs_record_iterator_t::write<uint16_t> (uint16_t);
 template uint16_t rcs_record_iterator_t::read<uint16_t> ();

-template ecma_magic_string_id_t lit_magic_record_t::get_magic_str_id<ecma_magic_string_id_t>() const;
-template ecma_magic_string_ex_id_t lit_magic_record_t::get_magic_str_id<ecma_magic_string_ex_id_t>() const;
-template void lit_magic_record_t::set_magic_str_id<ecma_magic_string_id_t>(ecma_magic_string_id_t);
-template void lit_magic_record_t::set_magic_str_id<ecma_magic_string_ex_id_t>(ecma_magic_string_ex_id_t);
+template lit_magic_string_id_t lit_magic_record_t::get_magic_str_id<lit_magic_string_id_t>() const;
+template lit_magic_string_ex_id_t lit_magic_record_t::get_magic_str_id<lit_magic_string_ex_id_t>() const;
+template void lit_magic_record_t::set_magic_str_id<lit_magic_string_id_t>(lit_magic_string_id_t);
+template void lit_magic_record_t::set_magic_str_id<lit_magic_string_ex_id_t>(lit_magic_string_ex_id_t);

 template lit_charset_record_t *rcs_recordset_t::alloc_record<lit_charset_record_t> (rcs_record_t::type_t type,
                                                                                    size_t size);
@@ -97,10 +97,10 @@ public:
   *
   * @return hash value of the string (the value of the 'hash' field in the header)
   */
-  ecma_string_hash_t
+  lit_string_hash_t
  get_hash () const
  {
-    return (ecma_string_hash_t) get_field (_hash_field_pos, _hash_field_width);
+    return (lit_string_hash_t) get_field (_hash_field_pos, _hash_field_width);
  } /* get_hash */

  /**
@@ -150,7 +150,7 @@ private:
   * Set record's hash (the value of the 'hash' field in the header)
   */
  void
-  set_hash (ecma_string_hash_t hash) /**< hash value */
+  set_hash (lit_string_hash_t hash) /**< hash value */
  {
    set_field (_hash_field_pos, _hash_field_width, hash);
  } /* set_hash */
@@ -242,7 +242,7 @@ public:
  magic_string_id_t get_magic_str_id () const
  {
    uint32_t id = get_field (magic_field_pos, magic_field_width);
-    // JERRY_ASSERT (id < ECMA_MAGIC_STRING__COUNT);
+    // JERRY_ASSERT (id < LIT_MAGIC_STRING__COUNT);
    return (magic_string_id_t) id;
  } /* get_magic_str_id */

@@ -418,8 +418,8 @@ public:
  };

  lit_charset_record_t *create_charset_record (const ecma_char_t *, size_t);
-  lit_magic_record_t *create_magic_record (ecma_magic_string_id_t);
-  lit_magic_record_t *create_magic_record_ex (ecma_magic_string_ex_id_t);
+  lit_magic_record_t *create_magic_record (lit_magic_string_id_t);
+  lit_magic_record_t *create_magic_record_ex (lit_magic_string_ex_id_t);
  lit_number_record_t *create_number_record (ecma_number_t);

  void dump ();
@@ -24,6 +24,8 @@ lit_init ()
 {
  new (&lit_storage) lit_literal_storage_t ();
  lit_storage.init ();
+  lit_magic_strings_init ();
+  lit_magic_strings_ex_init ();
 } /* lit_init */

 /**
@@ -57,31 +59,31 @@ lit_create_literal_from_charset (const ecma_char_t *str, /**< string to initiali
                                 ecma_length_t len)      /**< length of the string */
 {
  JERRY_ASSERT (str || !len);
-  for (ecma_magic_string_id_t msi = (ecma_magic_string_id_t) 0;
-       msi < ECMA_MAGIC_STRING__COUNT;
-       msi = (ecma_magic_string_id_t) (msi + 1))
+  for (lit_magic_string_id_t msi = (lit_magic_string_id_t) 0;
+       msi < LIT_MAGIC_STRING__COUNT;
+       msi = (lit_magic_string_id_t) (msi + 1))
  {
-    if (ecma_zt_string_length (ecma_get_magic_string_zt (msi)) != len)
+    if (ecma_zt_string_length (lit_get_magic_string_zt (msi)) != len)
    {
      continue;
    }

-    if (!strncmp ((const char *) str, (const char *) ecma_get_magic_string_zt (msi), len))
+    if (!strncmp ((const char *) str, (const char *) lit_get_magic_string_zt (msi), len))
    {
      return lit_storage.create_magic_record (msi);
    }
  }

-  for (ecma_magic_string_ex_id_t msi = (ecma_magic_string_ex_id_t) 0;
+  for (lit_magic_string_ex_id_t msi = (lit_magic_string_ex_id_t) 0;
       msi < ecma_get_magic_string_ex_count ();
-       msi = (ecma_magic_string_ex_id_t) (msi + 1))
+       msi = (lit_magic_string_ex_id_t) (msi + 1))
  {
-    if (ecma_zt_string_length (ecma_get_magic_string_ex_zt (msi)) != len)
+    if (ecma_zt_string_length (lit_get_magic_string_ex_zt (msi)) != len)
    {
      continue;
    }

-    if (!strncmp ((const char *) str, (const char *) ecma_get_magic_string_ex_zt (msi), len))
+    if (!strncmp ((const char *) str, (const char *) lit_get_magic_string_ex_zt (msi), len))
    {
      return lit_storage.create_magic_record_ex (msi);
    }
@@ -119,8 +121,8 @@ lit_find_literal_by_charset (const ecma_char_t *str, /**< a string to search for
    }
    else if (type == LIT_MAGIC_STR_T)
    {
-      ecma_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
-      const char *magic_str = (const char *) ecma_get_magic_string_zt (magic_id);
+      lit_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
+      const char *magic_str = (const char *) lit_get_magic_string_zt (magic_id);

      if (strlen (magic_str) != len)
      {
@@ -134,8 +136,8 @@ lit_find_literal_by_charset (const ecma_char_t *str, /**< a string to search for
    }
    else if (type == LIT_MAGIC_STR_EX_T)
    {
-      ecma_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
-      const char *magic_str = (const char *) ecma_get_magic_string_ex_zt (magic_id);
+      lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
+      const char *magic_str = (const char *) lit_get_magic_string_ex_zt (magic_id);

      if (strlen (magic_str) != len)
      {
@@ -248,11 +250,11 @@ lit_literal_equal_charset_rec (literal_t lit,                /**< literal to com
    }
    case LIT_MAGIC_STR_T:
    {
-      return record->equal_zt (ecma_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit)));
+      return record->equal_zt (lit_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit)));
    }
    case LIT_MAGIC_STR_EX_T:
    {
-      return record->equal_zt (ecma_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit)));
+      return record->equal_zt (lit_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit)));
    }
    case LIT_NUMBER_T:
    {
@@ -288,13 +290,13 @@ lit_literal_equal_zt (literal_t lit,          /**< literal to compare */
    }
    case LIT_MAGIC_STR_T:
    {
-      ecma_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
-      return ecma_compare_zt_strings (str, ecma_get_magic_string_zt (magic_id));
+      lit_magic_string_id_t magic_id = lit_magic_record_get_magic_str_id (lit);
+      return ecma_compare_zt_strings (str, lit_get_magic_string_zt (magic_id));
    }
    case LIT_MAGIC_STR_EX_T:
    {
-      ecma_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
-      return ecma_compare_zt_strings (str, ecma_get_magic_string_ex_zt (magic_id));
+      lit_magic_string_ex_id_t magic_id = lit_magic_record_ex_get_magic_str_id (lit);
+      return ecma_compare_zt_strings (str, lit_get_magic_string_ex_zt (magic_id));
    }
    case LIT_NUMBER_T:
    {
@@ -346,11 +348,11 @@ lit_literal_equal (literal_t lit1, /**< first literal */
    }
    case lit_literal_storage_t::LIT_MAGIC_STR:
    {
-      return lit_literal_equal_zt (lit1, ecma_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit2)));
+      return lit_literal_equal_zt (lit1, lit_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit2)));
    }
    case lit_literal_storage_t::LIT_MAGIC_STR_EX:
    {
-      return lit_literal_equal_zt (lit1, ecma_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit2)));
+      return lit_literal_equal_zt (lit1, lit_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit2)));
    }
    case lit_literal_storage_t::LIT_NUMBER:
    {
@@ -455,11 +457,11 @@ lit_literal_to_charset (literal_t lit,     /**< literal to be processed */
    }
    case LIT_MAGIC_STR_T:
    {
-      return ecma_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit));
+      return lit_get_magic_string_zt (lit_magic_record_get_magic_str_id (lit));
    }
    case LIT_MAGIC_STR_EX_T:
    {
-      return ecma_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit));
+      return lit_get_magic_string_ex_zt (lit_magic_record_ex_get_magic_str_id (lit));
    }
    case LIT_NUMBER_T:
    {
@@ -524,22 +526,22 @@ lit_get_literal_by_cp (lit_cpointer_t lit_cp) /**< compressed pointer to literal
  return lit;
 } /* lit_get_literal_by_cp */

-ecma_string_hash_t
+lit_string_hash_t
 lit_charset_literal_get_hash (literal_t lit) /**< literal */
 {
  return static_cast<lit_charset_record_t *> (lit)->get_hash ();
 } /* lit_charset_literal_get_hash */

-ecma_magic_string_id_t
+lit_magic_string_id_t
 lit_magic_record_get_magic_str_id (literal_t lit) /**< literal */
 {
-  return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<ecma_magic_string_id_t> ();
+  return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<lit_magic_string_id_t> ();
 } /* lit_magic_record_get_magic_str_id */

-ecma_magic_string_ex_id_t
+lit_magic_string_ex_id_t
 lit_magic_record_ex_get_magic_str_id (literal_t lit) /**< literal */
 {
-  return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<ecma_magic_string_ex_id_t> ();
+  return static_cast<lit_magic_record_t *> (lit)->get_magic_str_id<lit_magic_string_ex_id_t> ();
 } /* lit_magic_record_ex_get_magic_str_id */

 int32_t
@@ -46,11 +46,11 @@ const char *lit_literal_to_str_internal_buf (literal_t);

 literal_t lit_get_literal_by_cp (lit_cpointer_t);

-ecma_string_hash_t lit_charset_literal_get_hash (literal_t);
+lit_string_hash_t lit_charset_literal_get_hash (literal_t);
 ecma_number_t lit_charset_literal_get_number (literal_t);
 int32_t lit_charset_record_get_length (literal_t);

-ecma_magic_string_id_t lit_magic_record_get_magic_str_id (literal_t);
-ecma_magic_string_ex_id_t lit_magic_record_ex_get_magic_str_id (literal_t);
+lit_magic_string_id_t lit_magic_record_get_magic_str_id (literal_t);
+lit_magic_string_ex_id_t lit_magic_record_ex_get_magic_str_id (literal_t);

 #endif /* LIT_LITERAL_H */
@@ -0,0 +1,245 @@
+/* Copyright 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "lit-magic-strings.h"
+
+#include "ecma-helpers.h"
+
+/**
+ * Lengths of magic strings
+ */
+static ecma_length_t lit_magic_string_lengths[LIT_MAGIC_STRING__COUNT];
+
+/**
+ * External magic strings data array, count and lengths
+ */
+static const ecma_char_ptr_t *lit_magic_string_ex_array = NULL;
+static uint32_t lit_magic_string_ex_count = 0;
+static const ecma_length_t *lit_magic_string_ex_lengths = NULL;
+
+#ifndef JERRY_NDEBUG
+/**
+ * Maximum length among lengths of magic strings
+ */
+static ecma_length_t lit_magic_string_max_length;
+#endif /* !JERRY_NDEBUG */
+
+/**
+ * Initialize data for string helpers
+ */
+void
+lit_magic_strings_init (void)
+{
+  /* Initializing magic strings information */
+
+#ifndef JERRY_NDEBUG
+  lit_magic_string_max_length = 0;
+#endif /* !JERRY_NDEBUG */
+
+  for (lit_magic_string_id_t id = (lit_magic_string_id_t) 0;
+       id < LIT_MAGIC_STRING__COUNT;
+       id = (lit_magic_string_id_t) (id + 1))
+  {
+    lit_magic_string_lengths[id] = ecma_zt_string_length (lit_get_magic_string_zt (id));
+
+#ifndef JERRY_NDEBUG
+    lit_magic_string_max_length = JERRY_MAX (lit_magic_string_max_length, lit_magic_string_lengths[id]);
+
+    JERRY_ASSERT (lit_magic_string_max_length <= LIT_MAGIC_STRING_LENGTH_LIMIT);
+#endif /* !JERRY_NDEBUG */
+  }
+} /* ecma_strings_init */
+
+/**
+ * Initialize external magic strings
+ */
+void
+lit_magic_strings_ex_init (void)
+{
+  lit_magic_string_ex_array = NULL;
+  lit_magic_string_ex_count = 0;
+  lit_magic_string_ex_lengths = NULL;
+} /* ecma_strings_ex_init */
+
+/**
+ * Register external magic strings
+ */
+void
+lit_magic_strings_ex_set (const ecma_char_ptr_t* ex_str_items, /**< character arrays, representing
+                                                                *   external magic strings' contents */
+                          uint32_t count,                      /**< number of the strings */
+                          const ecma_length_t* ex_str_lengths) /**< lengths of the strings */
+{
+  JERRY_ASSERT (ex_str_items != NULL);
+  JERRY_ASSERT (count > 0);
+  JERRY_ASSERT (ex_str_lengths != NULL);
+
+  JERRY_ASSERT (lit_magic_string_ex_array == NULL);
+  JERRY_ASSERT (lit_magic_string_ex_count == 0);
+  JERRY_ASSERT (lit_magic_string_ex_lengths == NULL);
+
+  /* Set external magic strings information */
+  lit_magic_string_ex_array = ex_str_items;
+  lit_magic_string_ex_count = count;
+  lit_magic_string_ex_lengths = ex_str_lengths;
+
+#ifndef JERRY_NDEBUG
+  for (lit_magic_string_ex_id_t id = (lit_magic_string_ex_id_t) 0;
+       id < lit_magic_string_ex_count;
+       id = (lit_magic_string_ex_id_t) (id + 1))
+  {
+    JERRY_ASSERT (lit_magic_string_ex_lengths[id] == ecma_zt_string_length (lit_get_magic_string_ex_zt (id)));
+
+    lit_magic_string_max_length = JERRY_MAX (lit_magic_string_max_length, lit_magic_string_ex_lengths[id]);
+
+    JERRY_ASSERT (lit_magic_string_max_length <= LIT_MAGIC_STRING_LENGTH_LIMIT);
+  }
+#endif /* !JERRY_NDEBUG */
+} /* ecma_strings_ex_init */
+
+/**
+ * Get number of external magic strings
+ *
+ * @return number of the strings, if there were registered,
+ *         zero - otherwise.
+ */
+uint32_t
+ecma_get_magic_string_ex_count (void)
+{
+  return lit_magic_string_ex_count;
+} /* ecma_get_magic_string_ex_count */
+
+/**
+ * Get specified magic string as zero-terminated string
+ *
+ * @return pointer to zero-terminated magic string
+ */
+const ecma_char_t *
+lit_get_magic_string_zt (lit_magic_string_id_t id) /**< magic string id */
+{
+  TODO (Support UTF-16);
+
+  switch (id)
+  {
+#define LIT_MAGIC_STRING_DEF(id, ascii_zt_string) \
+     case id: return (ecma_char_t*) ascii_zt_string;
+#include "lit-magic-strings.inc.h"
+#undef LIT_MAGIC_STRING_DEF
+
+    case LIT_MAGIC_STRING__COUNT: break;
+  }
+
+  JERRY_UNREACHABLE ();
+} /* lit_get_magic_string_zt */
+
+/**
+ * Get length of specified magic string
+ *
+ * @return length
+ */
+ecma_length_t
+lit_get_magic_string_length (lit_magic_string_id_t id) /**< magic string id */
+{
+  return lit_magic_string_lengths[id];
+} /* ecma_get_magic_string_size */
+
+/**
+ * Get specified magic string as zero-terminated string from external table
+ *
+ * @return pointer to zero-terminated magic string
+ */
+const ecma_char_t*
+lit_get_magic_string_ex_zt (lit_magic_string_ex_id_t id) /**< extern magic string id */
+{
+  TODO (Support UTF-16);
+
+  if (lit_magic_string_ex_array && id < lit_magic_string_ex_count)
+  {
+    return lit_magic_string_ex_array[id];
+  }
+
+  JERRY_UNREACHABLE ();
+} /* lit_get_magic_string_ex_zt */
+
+/**
+ * Get length of specified external magic string
+ *
+ * @return length
+ */
+ecma_length_t
+lit_get_magic_string_ex_length (lit_magic_string_ex_id_t id) /**< external magic string id */
+{
+  return lit_magic_string_ex_lengths[id];
+} /* lit_get_magic_string_ex_length */
+
+/**
+ * Check if passed zt-string equals to one of magic strings
+ * and if equal magic string was found, return it's id in 'out_id_p' argument.
+ *
+ * @return true - if magic string equal to passed string was found,
+ *         false - otherwise.
+ */
+bool
+lit_is_zt_string_magic (const ecma_char_t *zt_string_p, /**< zero-terminated string */
+                         lit_magic_string_id_t *out_id_p) /**< out: magic string's id */
+{
+  TODO (Improve performance of search);
+
+  for (lit_magic_string_id_t id = (lit_magic_string_id_t) 0;
+       id < LIT_MAGIC_STRING__COUNT;
+       id = (lit_magic_string_id_t) (id + 1))
+  {
+    if (ecma_compare_zt_strings (zt_string_p, lit_get_magic_string_zt (id)))
+    {
+      *out_id_p = id;
+
+      return true;
+    }
+  }
+
+  *out_id_p = LIT_MAGIC_STRING__COUNT;
+
+  return false;
+} /* lit_is_zt_string_magic */
+
+/**
+ * Check if passed zt-string equals to one of external magic strings
+ * and if equal magic string was found, return it's id in 'out_id_p' argument.
+ *
+ * @return true - if external magic string equal to passed string was found,
+ *         false - otherwise.
+ */
+bool
+lit_is_zt_ex_string_magic (const ecma_char_t *zt_string_p, /**< zero-terminated string */
+                            lit_magic_string_ex_id_t *out_id_p) /**< out: external magic string's id */
+{
+  TODO (Improve performance of search);
+
+  for (lit_magic_string_ex_id_t id = (lit_magic_string_ex_id_t) 0;
+       id < lit_magic_string_ex_count;
+       id = (lit_magic_string_ex_id_t) (id + 1))
+  {
+    if (ecma_compare_zt_strings (zt_string_p, lit_get_magic_string_ex_zt (id)))
+    {
+      *out_id_p = id;
+
+      return true;
+    }
+  }
+
+  *out_id_p = lit_magic_string_ex_count;
+
+  return false;
+} /* lit_is_zt_ex_string_magic */
@@ -0,0 +1,61 @@
+/* Copyright 2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIT_MAGIC_STRINGS_H
+#define LIT_MAGIC_STRINGS_H
+
+#include "lit-globals.h"
+
+/**
+ * Limit for magic string length
+ */
+#define LIT_MAGIC_STRING_LENGTH_LIMIT 32
+
+/**
+ * Identifiers of ECMA and implementation-defined magic string constants
+ */
+typedef enum
+{
+#define LIT_MAGIC_STRING_DEF(id, ascii_zt_string) \
+     id,
+#include "lit-magic-strings.inc.h"
+#undef LIT_MAGIC_STRING_DEF
+
+  LIT_MAGIC_STRING__COUNT /**< number of magic strings */
+} lit_magic_string_id_t;
+
+/**
+ * Identifiers of implementation-defined external magic string constants
+ */
+typedef uint32_t lit_magic_string_ex_id_t;
+
+extern void lit_magic_strings_init (void);
+extern void lit_magic_strings_ex_init (void);
+
+extern void lit_magic_strings_ex_set (const ecma_char_ptr_t *,
+                                      uint32_t,
+                                      const ecma_length_t *);
+extern uint32_t ecma_get_magic_string_ex_count (void);
+
+extern const ecma_char_t *lit_get_magic_string_zt (lit_magic_string_id_t);
+extern ecma_length_t lit_get_magic_string_length (lit_magic_string_id_t);
+
+extern const ecma_char_t *lit_get_magic_string_ex_zt (lit_magic_string_ex_id_t);
+extern ecma_length_t lit_get_magic_string_ex_length (lit_magic_string_ex_id_t);
+
+extern bool lit_is_zt_string_magic (const ecma_char_t *, lit_magic_string_id_t *);
+extern bool lit_is_zt_ex_string_magic (const ecma_char_t *, lit_magic_string_ex_id_t *);
+
+#endif /* LIT_MAGIC_STRINGS_H */
@@ -0,0 +1,232 @@
+/* Copyright 2014-2015 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * List of ECMA magic strings
+ */
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ARGUMENTS, "arguments")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EVAL, "eval")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PROTOTYPE, "prototype")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CONSTRUCTOR, "constructor")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CALLER, "caller")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CALLEE, "callee")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_UNDEFINED, "undefined")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NULL, "null")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FALSE, "false")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TRUE, "true")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_BOOLEAN, "boolean")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NUMBER, "number")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_STRING, "string")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_OBJECT, "object")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FUNCTION, "function")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LENGTH, "length")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SOURCE, "source")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GLOBAL, "global")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IGNORECASE_UL, "ignoreCase")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MULTILINE, "multiline")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_INDEX, "index")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_INPUT, "input")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LASTINDEX_UL, "lastIndex")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NAN, "NaN")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_INFINITY_UL, "Infinity")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_UNDEFINED_UL, "Undefined")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NULL_UL, "Null")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_OBJECT_UL, "Object")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FUNCTION_UL, "Function")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ARRAY_UL, "Array")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ARGUMENTS_UL, "Arguments")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_STRING_UL, "String")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_BOOLEAN_UL, "Boolean")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NUMBER_UL, "Number")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_DATE_UL, "Date")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REGEXP_UL, "RegExp")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REGEXP_SOURCE_UL, "Source")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ERROR_UL, "Error")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EVAL_ERROR_UL, "EvalError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_RANGE_ERROR_UL, "RangeError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REFERENCE_ERROR_UL, "ReferenceError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SYNTAX_ERROR_UL, "SyntaxError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TYPE_ERROR_UL, "TypeError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_URI_ERROR_UL, "URIError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MATH_UL, "Math")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_JSON_U, "JSON")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PARSE, "parse")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PARSE_INT, "parseInt")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PARSE_FLOAT, "parseFloat")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_NAN, "isNaN")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_FINITE, "isFinite")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_DECODE_URI, "decodeURI")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_DECODE_URI_COMPONENT, "decodeURIComponent")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ENCODE_URI, "encodeURI")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ENCODE_URI_COMPONENT, "encodeURIComponent")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_PROTOTYPE_OF_UL, "getPrototypeOf")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_OWN_PROPERTY_DESCRIPTOR_UL, "getOwnPropertyDescriptor")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_OWN_PROPERTY_NAMES_UL, "getOwnPropertyNames")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CREATE, "create")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_DEFINE_PROPERTY_UL, "defineProperty")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_DEFINE_PROPERTIES_UL, "defineProperties")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SEAL, "seal")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FREEZE, "freeze")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PREVENT_EXTENSIONS_UL, "preventExtensions")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_SEALED_UL, "isSealed")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_FROZEN_UL, "isFrozen")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_EXTENSIBLE, "isExtensible")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_KEYS, "keys")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_WRITABLE, "writable")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ENUMERABLE, "enumerable")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CONFIGURABLE, "configurable")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_VALUE, "value")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET, "get")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET, "set")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_E_U, "E")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LN10_U, "LN10")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LN2_U, "LN2")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LOG2E_U, "LOG2E")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LOG10E_U, "LOG10E")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PI_U, "PI")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SQRT1_2_U, "SQRT1_2")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SQRT2_U, "SQRT2")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ABS, "abs")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ACOS, "acos")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ASIN, "asin")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ATAN, "atan")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ATAN2, "atan2")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CEIL, "ceil")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_COS, "cos")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EXP, "exp")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FLOOR, "floor")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LOG, "log")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MAX, "max")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MIN, "min")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_POW, "pow")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_RANDOM, "random")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_ROUND, "round")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SIN, "sin")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SQRT, "sqrt")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TAN, "tan")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FROM_CHAR_CODE_UL, "fromCharCode")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_ARRAY_UL, "isArray")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_STRING_UL, "toString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_VALUE_OF_UL, "valueOf")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_LOCALE_STRING_UL, "toLocaleString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_HAS_OWN_PROPERTY_UL, "hasOwnProperty")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_IS_PROTOTYPE_OF_UL, "isPrototypeOf")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PROPERTY_IS_ENUMERABLE_UL, "propertyIsEnumerable")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CONCAT, "concat")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_POP, "pop")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_JOIN, "join")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_PUSH, "push")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REVERSE, "reverse")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SHIFT, "shift")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SLICE, "slice")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SORT, "sort")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SPLICE, "splice")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_UNSHIFT, "unshift")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_INDEX_OF_UL, "indexOf")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LAST_INDEX_OF_UL, "lastIndexOf")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EVERY, "every")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SOME, "some")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FOR_EACH_UL, "forEach")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MAP, "map")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_FILTER, "filter")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REDUCE, "reduce")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REDUCE_RIGHT_UL, "reduceRight")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CHAR_AT_UL, "charAt")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CHAR_CODE_AT_UL, "charCodeAt")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LOCALE_COMPARE_UL, "localeCompare")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MATCH, "match")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_REPLACE, "replace")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SEARCH, "search")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SPLIT, "split")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SUBSTRING, "substring")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_LOWER_CASE_UL, "toLowerCase")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_LOCALE_LOWER_CASE_UL, "toLocaleLowerCase")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_UPPER_CASE_UL, "toUpperCase")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_LOCALE_UPPER_CASE_UL, "toLocaleUpperCase")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TRIM, "trim")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_FIXED_UL, "toFixed")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_EXPONENTIAL_UL, "toExponential")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_PRECISION_UL, "toPrecision")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NOW, "now")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_DATE_STRING_UL, "toDateString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_TIME_STRING_UL, "toTimeString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_LOCALE_DATE_STRING_UL, "toLocaleDateString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_LOCALE_TIME_STRING_UL, "toLocaleTimeString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_TIME_UL, "getTime")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_FULL_YEAR_UL, "getFullYear")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_UTC_U, "UTC")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_FULL_YEAR_UL, "getUTCFullYear")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_MONTH_UL, "getMonth")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_MONTH_UL, "getUTCMonth")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_DATE_UL, "getDate")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_DATE_UL, "getUTCDate")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_DAY_UL, "getDay")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_DAY_UL, "getUTCDay")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_HOURS_UL, "getHours")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_HOURS_UL, "getUTCHours")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_MINUTES_UL, "getMinutes")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_MINUTES_UL, "getUTCMinutes")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_SECONDS_UL, "getSeconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_SECONDS_UL, "getUTCSeconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_MILLISECONDS_UL, "getMilliseconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_UTC_MILLISECONDS_UL, "getUTCMilliseconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_GET_TIMEZONE_OFFSET_UL, "getTimezoneOffset")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_TIME_UL, "setTime")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_MILLISECONDS_UL, "setMilliseconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_MILLISECONDS_UL, "setUTCMilliseconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_SECONDS_UL, "setSeconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_SECONDS_UL, "setUTCSeconds")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_MINUTES_UL, "setMinutes")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_MINUTES_UL, "setUTCMinutes")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_HOURS_UL, "setHours")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_HOURS_UL, "setUTCHours")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_DATE_UL, "setDate")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_DATE_UL, "setUTCDate")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_MONTH_UL, "setMonth")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_MONTH_UL, "setUTCMonth")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_FULL_YEAR_UL, "setFullYear")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SET_UTC_FULL_YEAR_UL, "setUTCFullYear")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_UTC_STRING_UL, "toUTCString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_ISO_STRING_UL, "toISOString")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TO_JSON_UL, "toJSON")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MAX_VALUE_U, "MAX_VALUE")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MIN_VALUE_U, "MIN_VALUE")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_POSITIVE_INFINITY_U, "POSITIVE_INFINITY")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NEGATIVE_INFINITY_U, "NEGATIVE_INFINITY")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_COMPACT_PROFILE_ERROR_UL, "CompactProfileError")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_APPLY, "apply")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_CALL, "call")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_BIND, "bind")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EXEC, "exec")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TEST, "test")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_NAME, "name")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_MESSAGE, "message")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_G_CHAR, "g")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_I_CHAR, "i")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_M_CHAR, "m")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SLASH_CHAR, "/")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_EMPTY_NON_CAPTURE_GROUP, "(?:)")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_LEFT_SQUARE_CHAR, "[")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_RIGHT_SQUARE_CHAR, "]")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_COLON_CHAR, ":")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_COMMA_CHAR, ",")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_SPACE_CHAR, " ")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING__EMPTY, "")
+
+/*
+ * Implementation-defined magic strings
+ */
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_JERRY_UL, "Jerry")
+LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING__FUNCTION_TO_STRING, "function(){/* ecmascript */}")