Implement function.toString operation

docs/02.API-REFERENCE.md

@@ -175,6 +175,8 @@ Possible compile time enabled feature types:
  - JERRY_FEATURE_GLOBAL_THIS - GlobalThisValue support
  - JERRY_FEATURE_PROMISE_CALLBACK - Promise callback support
  - JERRY_FEATURE_MODULE - Module support
+ - JERRY_FEATURE_WEAKREF - WeakRef support
+ - JERRY_FEATURE_FUNCTION_TO_STRING - function toString support
 
 *New in version 2.0*.
 
@@ -183,7 +185,8 @@ Possible compile time enabled feature types:
 *Changed in version 2.4*: Added `JERRY_FEATURE_BIGINT`, `JERRY_FEATURE_REALM` values.
 
 *Changed in version [[NEXT_RELEASE]]*: Added `JERRY_FEATURE_VM_THROW`, `JERRY_FEATURE_GLOBAL_THIS`,
-                                       `JERRY_FEATURE_PROMISE_CALLBACK`, and `JERRY_FEATURE_MODULE` values.
+                                       `JERRY_FEATURE_PROMISE_CALLBACK`, and `JERRY_FEATURE_MODULE`,
+                                       `JERRY_FEATURE_WEAKREF`, and `JERRY_FEATURE_FUNCTION_TO_STRING` values.
 
 ## jerry_container_type_t
 

jerry-core/CMakeLists.txt

@@ -24,6 +24,7 @@ set(JERRY_DEBUGGER                  OFF          CACHE BOOL   "Enable JerryScrip
 set(JERRY_ERROR_MESSAGES            OFF          CACHE BOOL   "Enable error messages?")
 set(JERRY_EXTERNAL_CONTEXT          OFF          CACHE BOOL   "Enable external context?")
 set(JERRY_PARSER                    ON           CACHE BOOL   "Enable javascript-parser?")
+set(JERRY_FUNCTION_TO_STRING        OFF          CACHE BOOL   "Enable function toString operation?")
 set(JERRY_LINE_INFO                 OFF          CACHE BOOL   "Enable line info?")
 set(JERRY_LOGGING                   OFF          CACHE BOOL   "Enable logging?")
 set(JERRY_MEM_STATS                 OFF          CACHE BOOL   "Enable memory statistics?")
@@ -83,6 +84,7 @@ message(STATUS "JERRY_DEBUGGER                 " ${JERRY_DEBUGGER})
 message(STATUS "JERRY_ERROR_MESSAGES           " ${JERRY_ERROR_MESSAGES})
 message(STATUS "JERRY_EXTERNAL_CONTEXT         " ${JERRY_EXTERNAL_CONTEXT})
 message(STATUS "JERRY_PARSER                   " ${JERRY_PARSER})
+message(STATUS "JERRY_FUNCTION_TO_STRING       " ${JERRY_FUNCTION_TO_STRING})
 message(STATUS "JERRY_LINE_INFO                " ${JERRY_LINE_INFO})
 message(STATUS "JERRY_LOGGING                  " ${JERRY_LOGGING} ${JERRY_LOGGING_MESSAGE})
 message(STATUS "JERRY_MEM_STATS                " ${JERRY_MEM_STATS})
@@ -135,6 +137,7 @@ set(SOURCE_CORE_FILES
   ecma/base/ecma-alloc.c
   ecma/base/ecma-gc.c
   ecma/base/ecma-errors.c
+  ecma/base/ecma-extended-info.c
   ecma/base/ecma-helpers-collection.c
   ecma/base/ecma-helpers-conversion.c
   ecma/base/ecma-helpers-errol.c
@@ -559,6 +562,9 @@ jerry_add_define01(JERRY_EXTERNAL_CONTEXT)
 # JS-Parser
 jerry_add_define01(JERRY_PARSER)
 
+# JS function toString
+jerry_add_define01(JERRY_FUNCTION_TO_STRING)
+
 # JS line info
 jerry_add_define01(JERRY_LINE_INFO)
 

jerry-core/api/jerry-snapshot.c

@@ -979,8 +979,13 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
       user_value = option_values_p->user_value;
     }
 
-    uint32_t script_size = (user_value != ECMA_VALUE_EMPTY ? sizeof (cbc_script_user_t)
-                                                           : sizeof (cbc_script_t));
+    size_t script_size = sizeof (cbc_script_t);
+
+    if (user_value != ECMA_VALUE_EMPTY)
+    {
+      script_size += sizeof (ecma_value_t);
+    }
+
     cbc_script_t *script_p = jmem_heap_alloc_block (script_size);
 
     CBC_SCRIPT_SET_TYPE (script_p, user_value, CBC_SCRIPT_REF_ONE);
@@ -1003,6 +1008,10 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
     script_p->resource_name = resource_name;
 #endif /* JERRY_RESOURCE_NAME */
 
+#if JERRY_FUNCTION_TO_STRING
+    script_p->source_code = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
+#endif /* JERRY_FUNCTION_TO_STRING */
+
     const uint8_t *literal_base_p = snapshot_data_p + header_p->lit_table_offset;
 
     bytecode_p = snapshot_load_compiled_code ((const uint8_t *) bytecode_p,
@@ -1021,7 +1030,7 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
 
     if (user_value != ECMA_VALUE_EMPTY)
     {
-      ((cbc_script_user_t *) script_p)->user_value = ecma_copy_value_if_not_object (user_value);
+      CBC_SCRIPT_GET_USER_VALUE (script_p) = ecma_copy_value_if_not_object (user_value);
     }
   }
 

jerry-core/api/jerry.c

@@ -1841,6 +1841,9 @@ jerry_is_feature_enabled (const jerry_feature_t feature) /**< feature to check *
 #if JERRY_MODULE_SYSTEM
           || feature == JERRY_FEATURE_MODULE
 #endif /* JERRY_MODULE_SYSTEM */
+#if JERRY_FUNCTION_TO_STRING
+          || feature == JERRY_FEATURE_FUNCTION_TO_STRING
+#endif /* JERRY_FUNCTION_TO_STRING */
           );
 } /* jerry_is_feature_enabled */
 
@@ -2801,7 +2804,7 @@ jerry_create_regexp_sz (const jerry_char_t *pattern_p, /**< zero-terminated UTF-
   jerry_assert_api_available ();
 
 #if JERRY_BUILTIN_REGEXP
-  if (!lit_is_valid_utf8_string (pattern_p, pattern_size))
+  if (!lit_is_valid_utf8_string (pattern_p, pattern_size, true))
   {
     return jerry_throw (ecma_raise_common_error (ECMA_ERR_MSG ("Input must be a valid utf8 string")));
   }
@@ -5130,7 +5133,8 @@ jerry_is_valid_utf8_string (const jerry_char_t *utf8_buf_p, /**< UTF-8 string */
                             jerry_size_t buf_size) /**< string size */
 {
   return lit_is_valid_utf8_string ((lit_utf8_byte_t *) utf8_buf_p,
-                                   (lit_utf8_size_t) buf_size);
+                                   (lit_utf8_size_t) buf_size,
+                                   true);
 } /* jerry_is_valid_utf8_string */
 
 /**
@@ -5490,7 +5494,7 @@ jerry_get_user_value (const jerry_value_t value) /**< jerry api value */
     return ECMA_VALUE_UNDEFINED;
   }
 
-  return ecma_copy_value (((cbc_script_user_t *) script_p)->user_value);
+  return ecma_copy_value (CBC_SCRIPT_GET_USER_VALUE (script_p));
 } /* jerry_get_user_value */
 
 /**

jerry-core/config.h

@@ -231,6 +231,19 @@
 # define JERRY_LCACHE 1
 #endif /* !defined (JERRY_LCACHE) */
 
+/**
+ * Enable/Disable function toString operation.
+ *
+ * Allowed values:
+ *  0: Disable function toString operation.
+ *  1: Enable function toString operation.
+ *
+ * Default value: 0
+ */
+#ifndef JERRY_FUNCTION_TO_STRING
+# define JERRY_FUNCTION_TO_STRING 0
+#endif /* !defined (JERRY_FUNCTION_TO_STRING) */
+
 /**
  * Enable/Disable line-info management inside the engine.
  *
@@ -634,6 +647,10 @@
 || ((JERRY_LCACHE != 0) && (JERRY_LCACHE != 1))
 # error "Invalid value for 'JERRY_LCACHE' macro."
 #endif
+#if !defined (JERRY_FUNCTION_TO_STRING) \
+|| ((JERRY_FUNCTION_TO_STRING != 0) && (JERRY_FUNCTION_TO_STRING != 1))
+# error "Invalid value for 'JERRY_FUNCTION_TO_STRING' macro."
+#endif
 #if !defined (JERRY_LINE_INFO) \
 || ((JERRY_LINE_INFO != 0) && (JERRY_LINE_INFO != 1))
 # error "Invalid value for 'JERRY_LINE_INFO' macro."

jerry-core/ecma/base/ecma-extended-info.c

@@ -0,0 +1,152 @@
+/* Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * 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 "byte-code.h"
+#include "ecma-helpers.h"
+#include "ecma-extended-info.h"
+
+#if JERRY_ESNEXT || JERRY_FUNCTION_TO_STRING
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmaextendedinfo Extended info
+ * @{
+ */
+
+/**
+ * Decodes an uint32_t number, and updates the buffer position.
+ *
+ * @return the decoded value
+ */
+uint32_t
+ecma_extended_info_decode_vlq (uint8_t **buffer_p) /**< [in/out] target buffer */
+{
+  uint8_t *source_p = *buffer_p;
+  uint32_t value = 0;
+
+  do
+  {
+    source_p--;
+    value = (value << ECMA_EXTENDED_INFO_VLQ_SHIFT) | (*source_p & ECMA_EXTENDED_INFO_VLQ_MASK);
+  }
+  while (*source_p & ECMA_EXTENDED_INFO_VLQ_CONTINUE);
+
+  *buffer_p = source_p;
+  return value;
+} /* ecma_extended_info_decode_vlq */
+
+/**
+ * Encodes an uint32_t number into a buffer.
+ */
+void
+ecma_extended_info_encode_vlq (uint8_t **buffer_p, /**< target buffer */
+                               uint32_t value) /**< encoded value */
+{
+  uint8_t *destination_p = *buffer_p - 1;
+
+  if (value <= ECMA_EXTENDED_INFO_VLQ_MASK)
+  {
+    *destination_p = (uint8_t) value;
+    *buffer_p = destination_p;
+    return;
+  }
+
+  uint32_t length = 0;
+  uint32_t current_value = value >> ECMA_EXTENDED_INFO_VLQ_SHIFT;
+
+  do
+  {
+    current_value >>= ECMA_EXTENDED_INFO_VLQ_SHIFT;
+    length++;
+  }
+  while (current_value > 0);
+
+  destination_p -= length;
+  *buffer_p = destination_p;
+
+  do
+  {
+    *destination_p++ = (uint8_t) (value | ECMA_EXTENDED_INFO_VLQ_CONTINUE);
+    value >>= ECMA_EXTENDED_INFO_VLQ_SHIFT;
+  }
+  while (value > 0);
+
+  **buffer_p &= ECMA_EXTENDED_INFO_VLQ_MASK;
+} /* ecma_extended_info_encode_vlq */
+
+/**
+ * Gets the encoded length of a number.
+ *
+ * @return encoded length
+ */
+uint32_t
+ecma_extended_info_get_encoded_length (uint32_t value) /**< encoded value */
+{
+  uint32_t length = 0;
+
+  do
+  {
+    value >>= ECMA_EXTENDED_INFO_VLQ_SHIFT;
+    length++;
+  }
+  while (value > 0);
+
+  return length;
+} /* ecma_extended_info_get_encoded_length */
+
+/**
+ * Get the extended info from a byte code
+ *
+ * @return pointer to the extended info
+ */
+uint8_t *
+ecma_compiled_code_resolve_extended_info (const ecma_compiled_code_t *bytecode_header_p) /**< compiled code */
+{
+  JERRY_ASSERT (bytecode_header_p != NULL);
+  JERRY_ASSERT (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_EXTENDED_INFO);
+
+  ecma_value_t *base_p = ecma_compiled_code_resolve_arguments_start (bytecode_header_p);
+
+#if JERRY_ESNEXT
+  if (CBC_FUNCTION_GET_TYPE (bytecode_header_p->status_flags) != CBC_FUNCTION_CONSTRUCTOR)
+  {
+    base_p--;
+  }
+
+  if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_TAGGED_LITERALS)
+  {
+    base_p--;
+  }
+#endif /* JERRY_ESNEXT */
+
+#if JERRY_LINE_INFO
+  if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_LINE_INFO)
+  {
+    base_p--;
+  }
+#endif /* JERRY_LINE_INFO */
+
+  JERRY_ASSERT (((uint8_t *) base_p)[-1] != 0);
+
+  return ((uint8_t *) base_p) - 1;
+} /* ecma_compiled_code_resolve_extended_info */
+
+#endif /* JERRY_ESNEXT || JERRY_FUNCTION_TO_STRING */
+
+/**
+ * @}
+ * @}
+ */

jerry-core/ecma/base/ecma-extended-info.h

@@ -0,0 +1,58 @@
+/* Copyright JS Foundation and other contributors, http://js.foundation
+ *
+ * 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 ECMA_EXTENDED_INFO_H
+#define ECMA_EXTENDED_INFO_H
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmaextendedinfo Extended info
+ * @{
+ */
+
+#if JERRY_ESNEXT || JERRY_FUNCTION_TO_STRING
+
+#include "ecma-globals.h"
+
+/**
+ * Vlq encoding: flag which is set for all bytes except the last one.
+ */
+#define ECMA_EXTENDED_INFO_VLQ_CONTINUE 0x80
+
+/**
+ * Vlq encoding: mask to decode the number fragment.
+ */
+#define ECMA_EXTENDED_INFO_VLQ_MASK 0x7f
+
+/**
+ * Vlq encoding: number of bits stored in a byte.
+ */
+#define ECMA_EXTENDED_INFO_VLQ_SHIFT 7
+
+uint32_t ecma_extended_info_decode_vlq (uint8_t **buffer_p);
+void ecma_extended_info_encode_vlq (uint8_t **buffer_p, uint32_t value);
+uint32_t ecma_extended_info_get_encoded_length (uint32_t value);
+
+uint8_t *ecma_compiled_code_resolve_extended_info (const ecma_compiled_code_t *bytecode_header_p);
+
+#endif /* JERRY_ESNEXT || JERRY_FUNCTION_TO_STRING */
+
+/**
+ * @}
+ * @}
+ */
+
+#endif /* !ECMA_EXTENDED_INFO_H */

jerry-core/ecma/base/ecma-gc.c

@@ -430,10 +430,10 @@ ecma_gc_mark_compiled_code (const ecma_compiled_code_t *compiled_code_p) /**< co
 
   if (CBC_SCRIPT_GET_TYPE (script_p) == CBC_SCRIPT_USER_OBJECT)
   {
-    cbc_script_user_t *script_user_p = (cbc_script_user_t *) script_p;
+    ecma_value_t user_value = CBC_SCRIPT_GET_USER_VALUE (script_p);
 
-    JERRY_ASSERT (ecma_is_value_object (script_user_p->user_value));
-    ecma_gc_set_object_visited (ecma_get_object_from_value (script_user_p->user_value));
+    JERRY_ASSERT (ecma_is_value_object (user_value));
+    ecma_gc_set_object_visited (ecma_get_object_from_value (user_value));
   }
 
 #if JERRY_BUILTIN_REALMS

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

@@ -130,6 +130,9 @@ typedef enum
 #if JERRY_ESNEXT
   ECMA_PARSE_INTERNAL_PRE_SCANNING = (1u << 16), /**< the parser is in pre-scanning mode */
 #endif /* JERRY_ESNEXT */
+#if JERRY_FUNCTION_TO_STRING
+  ECMA_PARSE_INTERNAL_HAS_4_BYTE_MARKER = (1u << 17), /**< source has 4 byte marker */
+#endif /* JERRY_FUNCTION_TO_STRING */
 #ifndef JERRY_NDEBUG
   /**
    * This flag represents an error in for in/of statements, which cannot be set