Refactor literal-storage to not use C++ features

JerryScript-DCO-1.0-Signed-off-by: Roland Takacs rtakacs.u-szeged@partner.samsung.com

Author: Roland Takacs

jerry-core/ecma/base/ecma-globals.h

@@ -28,7 +28,8 @@
 #include "lit-globals.h"
 #include "lit-magic-strings.h"
 #include "mem-allocator.h"
-#include "rcs-recordset.h"
+#include "rcs-globals.h"
+#include "rcs-cpointer.h"
 
 /** \addtogroup compressedpointer Compressed pointer
  * @{
@@ -792,8 +793,8 @@ FIXME (Move to library that should define the type (literal.h /* ? */))
 /**
  * Literal and compressed pointer to literal
  */
-typedef rcs_record_t *literal_t;
-typedef rcs_cpointer_t lit_cpointer_t;
+typedef record_t *literal_t;
+typedef cpointer_t lit_cpointer_t;
 
 /**
  * ECMA string-value descriptor

jerry-core/ecma/base/ecma-helpers-string.cpp

@@ -31,6 +31,7 @@
 #include "lit-magic-strings.h"
 #include "serializer.h"
 #include "vm.h"
+#include "rcs-records.h"
 
 /**
  * Maximum length of strings' concatenation
@@ -329,23 +330,26 @@ ecma_init_ecma_string_from_lit_cp (ecma_string_t *string_p, /**< descriptor to i
 #endif /* !JERRY_NDEBUG */
 
   literal_t lit = lit_get_literal_by_cp (lit_cp);
-  if (lit->get_type () == LIT_MAGIC_STR_T)
+  record_type_t type = rcs_record_get_type (lit);
+
+  if (RCS_RECORD_TYPE_IS_MAGIC_STR (type))
   {
     ecma_init_ecma_string_from_magic_string_id (string_p,
                                                 lit_magic_record_get_magic_str_id (lit),
                                                 is_stack_var);
 
     return;
   }
-  else if (lit->get_type () == LIT_MAGIC_STR_EX_T)
+
+  if (RCS_RECORD_TYPE_IS_MAGIC_STR_EX (type))
   {
     ecma_init_ecma_string_from_magic_string_ex_id (string_p,
                                                    lit_magic_record_ex_get_magic_str_id (lit),
                                                    is_stack_var);
     return;
   }
 
-  JERRY_ASSERT (lit->get_type () == LIT_STR_T);
+  JERRY_ASSERT (RCS_RECORD_TYPE_IS_CHARSET (type));
 
   string_p->refs = 1;
   string_p->is_stack_var = (is_stack_var != 0);
@@ -973,7 +977,7 @@ ecma_string_to_utf8_string (const ecma_string_t *string_desc_p, /**< ecma-string
     case ECMA_STRING_CONTAINER_LIT_TABLE:
     {
       literal_t lit = lit_get_literal_by_cp (string_desc_p->u.lit_cp);
-      JERRY_ASSERT (lit->get_type () == LIT_STR_T);
+      JERRY_ASSERT (RCS_RECORD_IS_CHARSET (lit));
       lit_literal_to_utf8_string (lit, buffer_p, (size_t) required_buffer_size);
       break;
     }
@@ -1309,7 +1313,7 @@ ecma_string_get_length (const ecma_string_t *string_p) /**< ecma-string */
   if (container == ECMA_STRING_CONTAINER_LIT_TABLE)
   {
     literal_t lit = lit_get_literal_by_cp (string_p->u.lit_cp);
-    JERRY_ASSERT (lit->get_type () == LIT_STR_T);
+    JERRY_ASSERT (RCS_RECORD_IS_CHARSET (lit));
     return lit_charset_record_get_length (lit);
   }
   else if (container == ECMA_STRING_CONTAINER_MAGIC_STRING)
@@ -1386,7 +1390,7 @@ ecma_string_get_size (const ecma_string_t *string_p) /**< ecma-string */
   if (container == ECMA_STRING_CONTAINER_LIT_TABLE)
   {
     literal_t lit = lit_get_literal_by_cp (string_p->u.lit_cp);
-    JERRY_ASSERT (lit->get_type () == LIT_STR_T);
+    JERRY_ASSERT (RCS_RECORD_IS_CHARSET (lit));
 
     return lit_charset_record_get_size (lit);
   }

jerry-core/ecma/builtin-objects/ecma-builtin-global.cpp

@@ -29,6 +29,7 @@
 #include "lit-strings.h"
 #include "vm.h"
 #include "jrt-libc-includes.h"
+#include "jrt-bit-fields.h"
 
 #define ECMA_BUILTINS_INTERNAL
 #include "ecma-builtins-internal.h"

jerry-core/jerry.cpp

@@ -1677,7 +1677,8 @@ jerry_parse_and_save_snapshot (const jerry_api_char_t* source_p, /**< script sou
   if (!jrt_write_to_buffer_by_offset (buffer_p,
                                       buffer_size,
                                       &buffer_write_offset,
-                                      version))
+                                      &version,
+                                      sizeof (version)))
   {
     return 0;
   }
@@ -1726,7 +1727,7 @@ jerry_parse_and_save_snapshot (const jerry_api_char_t* source_p, /**< script sou
     return 0;
   }
 
-  is_ok = jrt_write_to_buffer_by_offset (buffer_p, buffer_size, &header_offset, header);
+  is_ok = jrt_write_to_buffer_by_offset (buffer_p, buffer_size, &header_offset, &header, sizeof (header));
   JERRY_ASSERT (is_ok && header_offset < buffer_write_offset);
 
   return buffer_write_offset;
@@ -1771,7 +1772,8 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
   if (!jrt_read_from_buffer_by_offset (snapshot_data_p,
                                        snapshot_size,
                                        &snapshot_read,
-                                       &version))
+                                       &version,
+                                       sizeof (version)))
   {
     return JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT;
   }
@@ -1797,11 +1799,10 @@ jerry_exec_snapshot (const void *snapshot_p, /**< snapshot */
   lit_mem_to_snapshot_id_map_entry_t *lit_map_p = NULL;
   uint32_t literals_num;
 
-  if (!lit_load_literals_from_snapshot (snapshot_data_p + snapshot_read,
+  if (!rcs_load_literals_from_snapshot (snapshot_data_p + snapshot_read,
                                         header_p->lit_table_size,
                                         &lit_map_p,
-                                        &literals_num,
-                                        is_copy))
+                                        &literals_num))
   {
     JERRY_ASSERT (lit_map_p == NULL);
     return JERRY_COMPLETION_CODE_INVALID_SNAPSHOT_FORMAT;

jerry-core/jrt/jrt.h

@@ -226,58 +226,40 @@ inline void *operator new (size_t, void *where)
   return where;
 } /* operator new */
 
-/**
- * Read data of specified type (T) from specified buffer
- *
- * Note:
- *      Offset is in-out and is incremented if the read operation completes successfully.
- *
- * @return true, if read was successful, i.e. offset + sizeof (T) doesn't exceed buffer size,
- *         false - otherwise.
- */
-template<typename T>
-bool __attr_always_inline___
+inline bool
 jrt_read_from_buffer_by_offset (const uint8_t *buffer_p, /**< buffer */
                                 size_t buffer_size, /**< size of buffer */
                                 size_t *in_out_buffer_offset_p, /**< in: offset to read from,
                                                                  *   out: offset, incremented on sizeof (T) */
-                                T *out_data_p) /**< out: data */
+                                void *out_data_p, /**< out: data */
+                                size_t out_data_size) /**< size of the out_data */
 {
-  if (*in_out_buffer_offset_p + sizeof (T) > buffer_size)
+  if (*in_out_buffer_offset_p + out_data_size > buffer_size)
   {
     return false;
   }
 
-  memcpy (out_data_p, buffer_p + *in_out_buffer_offset_p, sizeof (T));
-  *in_out_buffer_offset_p += sizeof (T);
+  memcpy (out_data_p, buffer_p + *in_out_buffer_offset_p, out_data_size);
+  *in_out_buffer_offset_p += out_data_size;
 
   return true;
 } /* jrt_read_from_buffer_by_offset */
 
-/**
- * Write data of specified type (T) to specified buffer
- *
- * Note:
- *      Offset is in-out and is incremented if the write operation completes successfully.
- *
- * @return true, if write was successful, i.e. offset + sizeof (T) doesn't exceed buffer size,
- *         false - otherwise.
- */
-template<typename T>
-bool __attr_always_inline___
+inline bool
 jrt_write_to_buffer_by_offset (uint8_t *buffer_p, /**< buffer */
                                size_t buffer_size, /**< size of buffer */
                                size_t *in_out_buffer_offset_p, /**< in: offset to read from,
                                                                 *   out: offset, incremented on sizeof (T) */
-                               T data) /**< data */
+                               void *data_p, /**< data */
+                               size_t data_size) /**< size of data */
 {
-  if (*in_out_buffer_offset_p + sizeof (T) > buffer_size)
+  if (*in_out_buffer_offset_p + data_size > buffer_size)
   {
     return false;
   }
 
-  memcpy (buffer_p + *in_out_buffer_offset_p, &data, sizeof (T));
-  *in_out_buffer_offset_p += sizeof (T);
+  memcpy (buffer_p + *in_out_buffer_offset_p, data_p, data_size);
+  *in_out_buffer_offset_p += data_size;
 
   return true;
 } /* jrt_write_to_buffer_by_offset */