Renaming core -> jerry-core.

jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.cpp

@@ -0,0 +1,68 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-array-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID array_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup arrayprototype ECMA Array.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Array.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.4.4.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_array_prototype_object_to_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_array_prototype_object_to_string */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-array-prototype.inc.h

@@ -0,0 +1,70 @@
+/* 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.
+ */
+
+/*
+ * Array.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_ARRAY_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.4.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+// 15.4.4
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              0,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_array_prototype_object_to_string, 0, 0)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE
+

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

@@ -0,0 +1,112 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-array-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-array.inc.h"
+#define BUILTIN_UNDERSCORED_ID array
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup array ECMA Array object built-in
+ * @{
+ */
+
+/**
+ * The Array object's 'isArray' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.4.3.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_array_object_is_array (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                                    const ecma_value_t& arg) /**< first argument */
+{
+  ecma_simple_value_t is_array = ECMA_SIMPLE_VALUE_FALSE;
+
+  if (ecma_is_value_object (arg))
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (arg);
+
+    ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p,
+                                                                ECMA_INTERNAL_PROPERTY_CLASS);
+
+    if (class_prop_p->u.internal_property.value == ECMA_MAGIC_STRING_ARRAY_UL)
+    {
+      is_array = ECMA_SIMPLE_VALUE_TRUE;
+    }
+  }
+
+  return ecma_make_simple_completion_value (is_array);
+} /* ecma_builtin_array_object_is_array */
+
+/**
+ * Handle calling [[Call]] of built-in Array object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_array_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                  ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_builtin_array_dispatch_construct (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_array_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Array object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_array_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_array_object (arguments_list_p, arguments_list_len, true);
+} /* ecma_builtin_array_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-array.inc.h

@@ -0,0 +1,60 @@
+/* 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.
+ */
+
+/*
+ * Array description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_ARRAY)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.4.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_IS_ARRAY_UL, ecma_builtin_array_object_is_array, 1, 1)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE
+

jerry-core/ecma/builtin-objects/ecma-builtin-boolean-prototype.cpp

@@ -0,0 +1,133 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-boolean-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID boolean_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup booleanprototype ECMA Boolean.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Boolean.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.6.4.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_boolean_prototype_object_to_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  ecma_completion_value_t ret_value;
+
+  ECMA_TRY_CATCH (value_of_ret,
+                  ecma_builtin_boolean_prototype_object_value_of (this_arg),
+                  ret_value);
+
+  ecma_string_t *ret_str_p;
+
+  if (ecma_is_value_true (value_of_ret))
+  {
+    ret_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_TRUE);
+  }
+  else
+  {
+    JERRY_ASSERT (ecma_is_value_boolean (value_of_ret));
+
+    ret_str_p = ecma_get_magic_string (ECMA_MAGIC_STRING_FALSE);
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_string_value (ret_str_p));
+
+  ECMA_FINALIZE (value_of_ret);
+
+  return ret_value;
+} /* ecma_builtin_boolean_prototype_object_to_string */
+
+/**
+ * The Boolean.prototype object's 'valueOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.6.4.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_boolean_prototype_object_value_of (const ecma_value_t& this_arg) /**< this argument */
+{
+  if (ecma_is_value_boolean (this_arg))
+  {
+    return ecma_make_normal_completion_value (this_arg);
+  }
+  else if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+
+    ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
+
+    if (class_prop_p->u.internal_property.value == ECMA_MAGIC_STRING_BOOLEAN_UL)
+    {
+      ecma_property_t *prim_value_prop_p = ecma_get_internal_property (obj_p,
+                                                                       ECMA_INTERNAL_PROPERTY_PRIMITIVE_BOOLEAN_VALUE);
+
+      JERRY_ASSERT (prim_value_prop_p->u.internal_property.value < ECMA_SIMPLE_VALUE__COUNT);
+
+      ecma_simple_value_t prim_simple_value = (ecma_simple_value_t) prim_value_prop_p->u.internal_property.value;
+
+      ecma_value_t ret_boolean_value = ecma_make_simple_value (prim_simple_value);
+
+      JERRY_ASSERT (ecma_is_value_boolean (ret_boolean_value));
+
+      return ecma_make_normal_completion_value (ret_boolean_value);
+    }
+  }
+
+  return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+} /* ecma_builtin_boolean_prototype_object_value_of */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-boolean-prototype.inc.h

@@ -0,0 +1,56 @@
+/* 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.
+ */
+
+/*
+ * Boolean.prototype description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.6.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_BOOLEAN),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_boolean_prototype_object_to_string, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_VALUE_OF_UL,  ecma_builtin_boolean_prototype_object_value_of,  0, 0)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,99 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-boolean-object.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-boolean.inc.h"
+#define BUILTIN_UNDERSCORED_ID boolean
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup boolean ECMA Boolean object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Boolean object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_boolean_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                    ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_value_t arg_value;
+
+  if (arguments_list_len == 0)
+  {
+    arg_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
+  }
+  else
+  {
+    arg_value = arguments_list_p [0];
+  }
+
+  return ecma_op_to_boolean (arg_value);
+} /* ecma_builtin_boolean_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Boolean object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_boolean_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                         ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len == 0)
+  {
+    return ecma_op_create_boolean_object (ecma_make_simple_value (ECMA_SIMPLE_VALUE_FALSE));
+  }
+  else
+  {
+    return ecma_op_create_boolean_object (arguments_list_p[0]);
+  }
+} /* ecma_builtin_boolean_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-boolean.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * Boolean description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_BOOLEAN)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.6.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+// 15.6.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-compact-profile-error.cpp

@@ -0,0 +1,80 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-compact-profile-error.inc.h"
+#define BUILTIN_UNDERSCORED_ID compact_profile_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup compact_profile_error ECMA CompactProfileError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in CompactProfileError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_compact_profile_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                  ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_make_throw_obj_completion_value (ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR));
+} /* ecma_builtin_compact_profile_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in CompactProfileError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_compact_profile_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                       ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_make_throw_obj_completion_value (ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR));
+} /* ecma_builtin_compact_profile_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* CONFIG_ECMA_COMPACT_PROFILE */

jerry-core/ecma/builtin-objects/ecma-builtin-compact-profile-error.inc.h

@@ -0,0 +1,46 @@
+/* Copyright 2014 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.
+ */
+
+/*
+ * CompactProfileError description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              0,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.cpp

@@ -0,0 +1,206 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-error-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup errorprototype ECMA Error.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Error.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.11.4.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_error_prototype_object_to_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  ecma_completion_value_t ret_value;
+
+  // 2.
+  if (!ecma_is_value_object (this_arg))
+  {
+    ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+  }
+  else
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+    ecma_string_t *name_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_NAME);
+
+    ECMA_TRY_CATCH (name_get_ret_value,
+                    ecma_op_object_get (obj_p, name_magic_string_p),
+                    ret_value);
+
+    ecma_completion_value_t name_to_str_completion;
+
+    if (ecma_is_value_undefined (name_get_ret_value))
+    {
+      ecma_string_t *error_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_ERROR_UL);
+
+      name_to_str_completion = ecma_make_normal_completion_value (ecma_make_string_value (error_magic_string_p));
+    }
+    else
+    {
+      name_to_str_completion = ecma_op_to_string (name_get_ret_value);
+    }
+
+    if (unlikely (!ecma_is_completion_value_normal (name_to_str_completion)))
+    {
+      ret_value = ecma_copy_completion_value (name_to_str_completion);
+    }
+    else
+    {
+      ecma_string_t *message_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_MESSAGE);
+
+      ECMA_TRY_CATCH (msg_get_ret_value,
+                      ecma_op_object_get (obj_p, message_magic_string_p),
+                      ret_value);
+
+      ecma_completion_value_t msg_to_str_completion;
+
+      if (ecma_is_value_undefined (msg_get_ret_value))
+      {
+        ecma_string_t *empty_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING__EMPTY);
+
+        msg_to_str_completion = ecma_make_normal_completion_value (ecma_make_string_value (empty_magic_string_p));
+      }
+      else
+      {
+        msg_to_str_completion = ecma_op_to_string (msg_get_ret_value);
+      }
+
+      if (unlikely (!ecma_is_completion_value_normal (msg_to_str_completion)))
+      {
+        ret_value = ecma_copy_completion_value (msg_to_str_completion);
+      }
+      else
+      {
+        ecma_string_t *name_string_p = ecma_get_string_from_completion_value (name_to_str_completion);
+        ecma_string_t *msg_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
+
+        ecma_string_t *ret_str_p;
+
+        if (ecma_string_get_length (name_string_p) == 0)
+        {
+          ret_str_p = ecma_copy_or_ref_ecma_string (msg_string_p);
+        }
+        else if (ecma_string_get_length (msg_string_p) == 0)
+        {
+          ret_str_p = ecma_copy_or_ref_ecma_string (name_string_p);
+        }
+        else
+        {
+          const ecma_char_t *colon_zt_magic_string_p = ecma_get_magic_string_zt (ECMA_MAGIC_STRING_COLON_CHAR);
+          const ecma_char_t *space_zt_magic_string_p = ecma_get_magic_string_zt (ECMA_MAGIC_STRING_SPACE_CHAR);
+
+          const int32_t len = (ecma_string_get_length (name_string_p) +
+                               ecma_string_get_length (msg_string_p) +
+                               ecma_zt_string_length (colon_zt_magic_string_p) +
+                               ecma_zt_string_length (space_zt_magic_string_p));
+
+          const ssize_t buffer_size = (len + 1) * (ssize_t) sizeof (ecma_char_t);
+          ssize_t buffer_size_left = buffer_size;
+
+          MEM_DEFINE_LOCAL_ARRAY (ret_str_buffer, buffer_size, ecma_char_t);
+          ecma_char_t *ret_str_buffer_p = ret_str_buffer;
+
+          ssize_t bytes = ecma_string_to_zt_string (name_string_p, ret_str_buffer_p, buffer_size_left);
+          JERRY_ASSERT (bytes >= 1 && buffer_size_left - bytes >= 0);
+
+          buffer_size_left -= bytes - 1 /* null character */;
+          ret_str_buffer_p = (ecma_char_t*) ((uint8_t*) ret_str_buffer + (buffer_size - buffer_size_left));
+
+          ret_str_buffer_p = ecma_copy_zt_string_to_buffer (colon_zt_magic_string_p,
+                                                            ret_str_buffer_p,
+                                                            buffer_size_left);
+          buffer_size_left = buffer_size - (ret_str_buffer_p - ret_str_buffer) * (ssize_t) sizeof (ecma_char_t);
+          JERRY_ASSERT (buffer_size_left >= 0);
+
+          ret_str_buffer_p = ecma_copy_zt_string_to_buffer (space_zt_magic_string_p,
+                                                            ret_str_buffer_p,
+                                                            buffer_size_left);
+          buffer_size_left = buffer_size - (ret_str_buffer_p - ret_str_buffer) * (ssize_t) sizeof (ecma_char_t);
+          JERRY_ASSERT (buffer_size_left >= 0);
+
+          bytes = ecma_string_to_zt_string (msg_string_p, ret_str_buffer_p, buffer_size_left);
+          JERRY_ASSERT (bytes >= 1 && buffer_size_left - bytes >= 0);
+
+          buffer_size_left -= bytes - 1 /* null character */;
+          ret_str_buffer_p = (ecma_char_t*) ((uint8_t*) ret_str_buffer + (buffer_size - buffer_size_left));
+
+          JERRY_ASSERT (buffer_size_left >= (ssize_t) sizeof (ecma_char_t));
+          *ret_str_buffer_p = ECMA_CHAR_NULL;
+
+          ret_str_p = ecma_new_ecma_string (ret_str_buffer);
+
+          MEM_FINALIZE_LOCAL_ARRAY (ret_str_buffer);
+        }
+
+        ret_value = ecma_make_normal_completion_value (ecma_make_string_value (ret_str_p));
+      }
+
+      ecma_free_completion_value (msg_to_str_completion);
+
+      ECMA_FINALIZE (msg_get_ret_value);
+
+      ecma_deref_ecma_string (message_magic_string_p);
+    }
+
+    ecma_free_completion_value (name_to_str_completion);
+
+    ECMA_FINALIZE (name_get_ret_value);
+
+    ecma_deref_ecma_string (name_magic_string_p);
+  }
+
+  return ret_value;
+} /* ecma_builtin_error_prototype_object_to_string */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-error-prototype.inc.h

@@ -0,0 +1,73 @@
+/* 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.
+ */
+
+/*
+ * Error.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.4.2
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.4.3
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_error_prototype_object_to_string, 0, 0)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-error.inc.h"
+#define BUILTIN_UNDERSCORED_ID error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup error ECMA Error object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Error object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                  ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_COMMON,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_COMMON);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Error object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-error.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * Error built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.7.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-evalerror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-evalerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID eval_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-evalerror-prototype.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * EvalError.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.7.8
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_EVAL_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.9
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_EVAL_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.10
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-evalerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID eval_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup evalerror ECMA EvalError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in EvalError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_eval_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_EVAL,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_EVAL);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_eval_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in EvalError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_eval_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                            ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_eval_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_eval_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-evalerror.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * EvalError built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_EVAL_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.cpp

@@ -0,0 +1,143 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-function-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID function_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup functionprototype ECMA Function.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Function.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_function_prototype_object_to_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_function_prototype_object_to_string */
+
+/**
+ * The Function.prototype object's 'apply' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_function_prototype_object_apply (const ecma_value_t& this_arg, /**< this argument */
+                                              const ecma_value_t& arg1, /**< first argument */
+                                              const ecma_value_t& arg2) /**< second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_function_prototype_object_apply */
+
+/**
+ * The Function.prototype object's 'call' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_function_prototype_object_call (const ecma_value_t& this_arg, /**< this argument */
+                                             const ecma_value_t* arguments_list_p, /**< list of arguments */
+                                             ecma_length_t arguments_number) /**< number of arguments */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arguments_list_p, arguments_number);
+} /* ecma_builtin_function_prototype_object_call */
+
+/**
+ * The Function.prototype object's 'bind' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.3.4.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_function_prototype_object_bind (const ecma_value_t& this_arg, /**< this argument */
+                                             const ecma_value_t* arguments_list_p, /**< list of arguments */
+                                             ecma_length_t arguments_number) /**< number of arguments */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arguments_list_p, arguments_number);
+} /* ecma_builtin_function_prototype_object_bind */
+
+/**
+ * Handle calling [[Call]] of built-in Function.prototype object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_function_prototype_dispatch_call (const ecma_value_t* arguments_list_p, /**< arguments list */
+                                               ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
+} /* ecma_builtin_function_prototype_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Function.prototype object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_function_prototype_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                    ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+} /* ecma_builtin_function_prototype_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtin-function-prototype.inc.h

@@ -0,0 +1,72 @@
+/* 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.
+ */
+
+/*
+ * Function.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.3.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+// 15.3.4
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              0,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_function_prototype_object_to_string, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_APPLY, ecma_builtin_function_prototype_object_apply, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_CALL, ecma_builtin_function_prototype_object_call, NON_FIXED, 1)
+ROUTINE (ECMA_MAGIC_STRING_BIND, ecma_builtin_function_prototype_object_bind, NON_FIXED, 1)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,77 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-function-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-function.inc.h"
+#define BUILTIN_UNDERSCORED_ID function
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup function ECMA Function object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Function object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_function_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                     ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_builtin_function_dispatch_construct (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_function_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Function object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                          ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_function_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtin-function.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * Function built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_FUNCTION)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.3.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Number properties:
+ *  (property name, object pointer getter) */
+
+// 15.3.3.2
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,215 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-global.inc.h"
+#define BUILTIN_UNDERSCORED_ID global
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup global ECMA Global object built-in
+ * @{
+ */
+
+/**
+ * The Global object's 'eval' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.1
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_eval (const ecma_value_t& this_arg, /**< this argument */
+                                 const ecma_value_t& x) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, x);
+} /* ecma_builtin_global_object_eval */
+
+/**
+ * The Global object's 'parseInt' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_parse_int (const ecma_value_t& this_arg, /**< this argument */
+                                      const ecma_value_t& string, /**< routine's first argument */
+                                      const ecma_value_t& radix) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, string, radix);
+} /* ecma_builtin_global_object_parse_int */
+
+/**
+ * The Global object's 'parseFloat' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_parse_float (const ecma_value_t& this_arg, /**< this argument */
+                                        const ecma_value_t& string) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, string);
+} /* ecma_builtin_global_object_parse_float */
+
+/**
+ * The Global object's 'isNaN' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_is_nan (const ecma_value_t& this_arg __attr_unused___, /**< this argument */
+                                   const ecma_value_t& arg) /**< routine's first argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  bool is_nan = ecma_number_is_nan (arg_num);
+
+  ret_value = ecma_make_simple_completion_value (is_nan ? ECMA_SIMPLE_VALUE_TRUE
+                                                        : ECMA_SIMPLE_VALUE_FALSE);
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_global_object_is_nan */
+
+/**
+ * The Global object's 'isFinite' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.2.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_is_finite (const ecma_value_t& this_arg __attr_unused___, /**< this argument */
+                                      const ecma_value_t& arg) /**< routine's first argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  bool is_finite = !(ecma_number_is_nan (arg_num)
+                     || ecma_number_is_infinity (arg_num));
+
+  ret_value = ecma_make_simple_completion_value (is_finite ? ECMA_SIMPLE_VALUE_TRUE
+                                                           : ECMA_SIMPLE_VALUE_FALSE);
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_global_object_is_finite */
+
+/**
+ * The Global object's 'decodeURI' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.3.1
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_decode_uri (const ecma_value_t& this_arg, /**< this argument */
+                                       const ecma_value_t& encoded_uri) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, encoded_uri);
+} /* ecma_builtin_global_object_decode_uri */
+
+/**
+ * The Global object's 'decodeURIComponent' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.3.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_decode_uri_component (const ecma_value_t& this_arg, /**< this argument */
+                                                 const ecma_value_t& encoded_uri_component) /**< routine's
+                                                                                             *   first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, encoded_uri_component);
+} /* ecma_builtin_global_object_decode_uri_component */
+
+/**
+ * The Global object's 'encodeURI' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.3.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_encode_uri (const ecma_value_t& this_arg, /**< this argument */
+                                       const ecma_value_t& uri) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, uri);
+} /* ecma_builtin_global_object_encode_uri */
+
+/**
+ * The Global object's 'encodeURIComponent' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.1.3.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_global_object_encode_uri_component (const ecma_value_t& this_arg, /**< this argument */
+                                                 const ecma_value_t& uri_component) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, uri_component);
+} /* ecma_builtin_global_object_encode_uri_component */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtin-global.inc.h

@@ -0,0 +1,234 @@
+/* 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.
+ */
+
+/*
+ * Global built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef SIMPLE_VALUE
+# define SIMPLE_VALUE(name, simple_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !SIMPLE_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef CP_UNIMPLEMENTED_VALUE
+# define CP_UNIMPLEMENTED_VALUE(name, value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !CP_UNIMPLEMENTED_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_GLOBAL)
+
+/* Simple value properties:
+ * (property name, simple value, writable, enumerable, configurable) */
+
+// ECMA-262 v5, 15.1.1.3
+SIMPLE_VALUE (ECMA_MAGIC_STRING_UNDEFINED,
+              ECMA_SIMPLE_VALUE_UNDEFINED,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// ECMA-262 v5, 15.1.1.1
+NUMBER_VALUE (ECMA_MAGIC_STRING_NAN,
+              ecma_number_make_nan (),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.1.2
+NUMBER_VALUE (ECMA_MAGIC_STRING_INFINITY_UL,
+              ecma_number_make_infinity (false),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// ECMA-262 v5, 15.1.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_OBJECT_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.2
+OBJECT_VALUE (ECMA_MAGIC_STRING_FUNCTION_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.3
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN
+OBJECT_VALUE (ECMA_MAGIC_STRING_ARRAY_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN*/
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN
+// ECMA-262 v5, 15.1.4.4
+OBJECT_VALUE (ECMA_MAGIC_STRING_STRING_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_STRING),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
+// ECMA-262 v5, 15.1.4.5
+OBJECT_VALUE (ECMA_MAGIC_STRING_BOOLEAN_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_BOOLEAN),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
+// ECMA-262 v5, 15.1.4.6
+OBJECT_VALUE (ECMA_MAGIC_STRING_NUMBER_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_NUMBER),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */
+
+// ECMA-262 v5, 15.1.4.7
+CP_UNIMPLEMENTED_VALUE (ECMA_MAGIC_STRING_DATE_UL,
+                        ecma_builtin_get (ECMA_BUILTIN_ID_DATE),
+                        ECMA_PROPERTY_WRITABLE,
+                        ECMA_PROPERTY_NOT_ENUMERABLE,
+                        ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.8
+CP_UNIMPLEMENTED_VALUE (ECMA_MAGIC_STRING_REG_EXP_UL,
+                        ecma_builtin_get (ECMA_BUILTIN_ID_REGEXP),
+                        ECMA_PROPERTY_WRITABLE,
+                        ECMA_PROPERTY_NOT_ENUMERABLE,
+                        ECMA_PROPERTY_CONFIGURABLE)
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+// ECMA-262 v5, 15.1.4.9
+OBJECT_VALUE (ECMA_MAGIC_STRING_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.10
+OBJECT_VALUE (ECMA_MAGIC_STRING_EVAL_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_EVAL_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.11
+OBJECT_VALUE (ECMA_MAGIC_STRING_RANGE_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_RANGE_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.12
+OBJECT_VALUE (ECMA_MAGIC_STRING_REFERENCE_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_REFERENCE_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.13
+OBJECT_VALUE (ECMA_MAGIC_STRING_SYNTAX_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_SYNTAX_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.14
+OBJECT_VALUE (ECMA_MAGIC_STRING_TYPE_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_TYPE_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// ECMA-262 v5, 15.1.4.15
+OBJECT_VALUE (ECMA_MAGIC_STRING_URI_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_URI_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_MATH_BUILTIN
+// ECMA-262 v5, 15.1.5.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_MATH_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_MATH),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_MATH_BUILTIN */
+
+// ECMA-262 v5, 15.1.5.2
+CP_UNIMPLEMENTED_VALUE (ECMA_MAGIC_STRING_JSON_U,
+                        ecma_builtin_get (ECMA_BUILTIN_ID_JSON),
+                        ECMA_PROPERTY_WRITABLE,
+                        ECMA_PROPERTY_NOT_ENUMERABLE,
+                        ECMA_PROPERTY_CONFIGURABLE)
+
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+OBJECT_VALUE (ECMA_MAGIC_STRING_COMPACT_PROFILE_ERROR_UL,
+              ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+#endif /* CONFIG_ECMA_COMPACT_PROFILE */
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_EVAL, ecma_builtin_global_object_eval, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_PARSE_FLOAT, ecma_builtin_global_object_parse_float, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_IS_NAN, ecma_builtin_global_object_is_nan, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_IS_FINITE, ecma_builtin_global_object_is_finite, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_DECODE_URI, ecma_builtin_global_object_decode_uri, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_DECODE_URI_COMPONENT, ecma_builtin_global_object_decode_uri_component, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_ENCODE_URI, ecma_builtin_global_object_encode_uri, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_ENCODE_URI_COMPONENT, ecma_builtin_global_object_encode_uri_component, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_PARSE_INT, ecma_builtin_global_object_parse_int, 2, 2)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-internal-routines-template.inc.h

@@ -0,0 +1,327 @@
+/* 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.
+ */
+
+#ifndef BUILTIN_UNDERSCORED_ID
+# error "Please, define BUILTIN_UNDERSCORED_ID"
+#endif /* !BUILTIN_UNDERSCORED_ID */
+
+#ifndef BUILTIN_INC_HEADER_NAME
+# error "Please, define BUILTIN_INC_HEADER_NAME"
+#endif /* !BUILTIN_INC_HEADER_NAME */
+
+#define PASTE__(x, y) x ## y
+#define PASTE_(x, y) PASTE__ (x, y)
+#define PASTE(x, y) PASTE_ (x, y)
+
+#define SORT_PROPERTY_NAMES_ROUTINE_NAME(builtin_underscored_id) \
+  PASTE (PASTE (ecma_builtin_, builtin_underscored_id), _sort_property_names)
+#define TRY_TO_INSTANTIATE_PROPERTY_ROUTINE_NAME(builtin_underscored_id) \
+  PASTE (PASTE (ecma_builtin_, builtin_underscored_id), _try_to_instantiate_property)
+#define DISPATCH_ROUTINE_ROUTINE_NAME(builtin_underscored_id) \
+  PASTE (PASTE (ecma_builtin_, builtin_underscored_id), _dispatch_routine)
+
+#define ROUTINE_ARG(n) , const ecma_value_t& arg ## n
+#define ROUTINE_ARG_LIST_0 const ecma_value_t& this_arg
+#define ROUTINE_ARG_LIST_1 ROUTINE_ARG_LIST_0 ROUTINE_ARG(1)
+#define ROUTINE_ARG_LIST_2 ROUTINE_ARG_LIST_1 ROUTINE_ARG(2)
+#define ROUTINE_ARG_LIST_3 ROUTINE_ARG_LIST_2 ROUTINE_ARG(3)
+#define ROUTINE_ARG_LIST_NON_FIXED ROUTINE_ARG_LIST_0, \
+  const ecma_value_t *arguments_list_p, ecma_length_t arguments_list_len
+#define ROUTINE(name, c_function_name, args_number, length_prop_value) \
+  static ecma_completion_value_t c_function_name (ROUTINE_ARG_LIST_ ## args_number);
+#include BUILTIN_INC_HEADER_NAME
+#undef ROUTINE_ARG_LIST_NON_FIXED
+#undef ROUTINE_ARG_LIST_3
+#undef ROUTINE_ARG_LIST_2
+#undef ROUTINE_ARG_LIST_1
+#undef ROUTINE_ARG_LIST_0
+#undef ROUTINE_ARG
+
+static ecma_magic_string_id_t ecma_builtin_property_names[] =
+{
+#define SIMPLE_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable) name,
+#define NUMBER_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable) name,
+#define STRING_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable) name,
+#define CP_UNIMPLEMENTED_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable) name,
+#define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable) name,
+#define ROUTINE(name, c_function_name, args_number, length_prop_value) name,
+#include BUILTIN_INC_HEADER_NAME
+};
+
+/**
+ * Sort builtin's property names array
+ */
+void
+SORT_PROPERTY_NAMES_ROUTINE_NAME (BUILTIN_UNDERSCORED_ID) (void)
+{
+  bool swapped;
+
+  do
+  {
+    swapped = false;
+
+    for (ecma_length_t i = 1;
+         i < (sizeof (ecma_builtin_property_names) / sizeof (ecma_builtin_property_names [0]));
+         i++)
+    {
+      if (ecma_builtin_property_names [i] < ecma_builtin_property_names [i - 1])
+      {
+        ecma_magic_string_id_t id_temp = ecma_builtin_property_names [i - 1];
+        ecma_builtin_property_names [i - 1] = ecma_builtin_property_names [i];
+        ecma_builtin_property_names [i] = id_temp;
+
+        swapped = true;
+      }
+    }
+  }
+  while (swapped);
+} /* SORT_PROPERTY_NAMES_ROUTINE_NAME */
+
+/**
+ * If the property's name is one of built-in properties of the built-in object
+ * that is not instantiated yet, instantiate the property and
+ * return pointer to the instantiated property.
+ *
+ * @return pointer property, if one was instantiated,
+ *         NULL - otherwise.
+ */
+ecma_property_t*
+TRY_TO_INSTANTIATE_PROPERTY_ROUTINE_NAME (BUILTIN_UNDERSCORED_ID) (ecma_object_t *obj_p, /**< object */
+                                                                   ecma_string_t *prop_name_p) /**< property's name */
+{
+#define OBJECT_ID(builtin_id) const ecma_builtin_id_t builtin_object_id = builtin_id;
+#include BUILTIN_INC_HEADER_NAME
+
+  JERRY_ASSERT (ecma_builtin_is (obj_p, builtin_object_id));
+  JERRY_ASSERT (ecma_find_named_property (obj_p, prop_name_p) == NULL);
+
+  ecma_magic_string_id_t id;
+
+  if (!ecma_is_string_magic (prop_name_p, &id))
+  {
+    return NULL;
+  }
+
+  const ecma_length_t property_numbers = (ecma_length_t) (sizeof (ecma_builtin_property_names) /
+                                                          sizeof (ecma_builtin_property_names [0]));
+  int32_t index;
+  index = ecma_builtin_bin_search_for_magic_string_id_in_array (ecma_builtin_property_names,
+                                                                property_numbers,
+                                                                id);
+
+  if (index == -1)
+  {
+    return NULL;
+  }
+
+  JERRY_ASSERT (index >= 0 && (uint32_t) index < sizeof (uint64_t) * JERRY_BITSINBYTE);
+
+  uint32_t bit;
+  ecma_internal_property_id_t mask_prop_id;
+
+  if (index >= 32)
+  {
+    mask_prop_id = ECMA_INTERNAL_PROPERTY_NON_INSTANTIATED_BUILT_IN_MASK_32_63;
+    bit = (uint32_t) 1u << (index - 32);
+  }
+  else
+  {
+    mask_prop_id = ECMA_INTERNAL_PROPERTY_NON_INSTANTIATED_BUILT_IN_MASK_0_31;
+    bit = (uint32_t) 1u << index;
+  }
+
+  ecma_property_t *mask_prop_p = ecma_find_internal_property (obj_p, mask_prop_id);
+  if (mask_prop_p == NULL)
+  {
+    mask_prop_p = ecma_create_internal_property (obj_p, mask_prop_id);
+    mask_prop_p->u.internal_property.value = 0;
+  }
+
+  uint32_t bit_mask = mask_prop_p->u.internal_property.value;
+
+  if (bit_mask & bit)
+  {
+    return NULL;
+  }
+
+  bit_mask |= bit;
+
+  mask_prop_p->u.internal_property.value = bit_mask;
+
+  ecma_value_t value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
+  ecma_property_writable_value_t writable;
+  ecma_property_enumerable_value_t enumerable;
+  ecma_property_configurable_value_t configurable;
+
+  switch (id)
+  {
+#define ROUTINE(name, c_function_name, args_number, length_prop_value) case name: \
+    { \
+      ecma_object_t *func_obj_p = ecma_builtin_make_function_object_for_routine (builtin_object_id, \
+                                                                                 id, \
+                                                                                 length_prop_value); \
+      \
+      writable = ECMA_PROPERTY_WRITABLE; \
+      enumerable = ECMA_PROPERTY_NOT_ENUMERABLE; \
+      configurable = ECMA_PROPERTY_CONFIGURABLE; \
+      \
+      value = ecma_make_object_value (func_obj_p); \
+      \
+      break; \
+    }
+#define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable) case name: \
+    { \
+      value = ecma_make_object_value (obj_getter); \
+      writable = prop_writable; \
+      enumerable = prop_enumerable; \
+      configurable = prop_configurable; \
+      break; \
+    }
+#define SIMPLE_VALUE(name, simple_value, prop_writable, prop_enumerable, prop_configurable) case name: \
+    { \
+      value = ecma_make_simple_value (simple_value); \
+      \
+      writable = prop_writable; \
+      enumerable = prop_enumerable; \
+      configurable = prop_configurable; \
+      \
+      break; \
+   }
+#define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable) case name: \
+    { \
+      ecma_number_t *num_p = ecma_alloc_number (); \
+      *num_p = number_value; \
+      \
+      value = ecma_make_number_value (num_p); \
+      \
+      writable = prop_writable; \
+      enumerable = prop_enumerable; \
+      configurable = prop_configurable; \
+      \
+      break; \
+    }
+#define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable) case name: \
+    { \
+      ecma_string_t *magic_string_p = ecma_get_magic_string (magic_string_id); \
+      \
+      value = ecma_make_string_value (magic_string_p); \
+      \
+      writable = prop_writable; \
+      enumerable = prop_enumerable; \
+      configurable = prop_configurable; \
+      \
+      break; \
+    }
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+#define CP_UNIMPLEMENTED_VALUE(name, value, prop_writable, prop_enumerable, prop_configurable) case name: \
+    { \
+      /* The object throws CompactProfileError upon invocation */ \
+      ecma_object_t *get_set_p = ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR); \
+      ecma_property_t *compact_profile_thrower_property_p = ecma_create_named_accessor_property (obj_p, \
+                                                                                                 prop_name_p, \
+                                                                                                 get_set_p, \
+                                                                                                 get_set_p, \
+                                                                                                 true, \
+                                                                                                 false); \
+      ecma_deref_object (get_set_p); \
+      \
+      return compact_profile_thrower_property_p; \
+    }
+#else /* CONFIG_ECMA_COMPACT_PROFILE */
+#define CP_UNIMPLEMENTED_VALUE(name, value, prop_writable, prop_enumerable, prop_configurable) case name: \
+      { \
+        JERRY_UNIMPLEMENTED ("The built-in is not implemented."); \
+      }
+#endif /* CONFIG_ECMA_COMPACT_PROFILE */
+#include BUILTIN_INC_HEADER_NAME
+
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+
+  ecma_property_t *prop_p = ecma_create_named_data_property (obj_p,
+                                                             prop_name_p,
+                                                             writable,
+                                                             enumerable,
+                                                             configurable);
+
+  ecma_named_data_property_assign_value (obj_p, prop_p, value);
+
+  ecma_free_value (value, true);
+
+  return prop_p;
+} /* TRY_TO_INSTANTIATE_PROPERTY_ROUTINE_NAME */
+
+/**
+ * Dispatcher of the built-in's routines
+ *
+ * @return completion-value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+ecma_completion_value_t
+DISPATCH_ROUTINE_ROUTINE_NAME (BUILTIN_UNDERSCORED_ID) (ecma_magic_string_id_t builtin_routine_id, /**< built-in's
+                                                                                                        routine's
+                                                                                                        name */
+                                                        const ecma_value_t& this_arg_value, /**< 'this' argument
+                                                                                                 value */
+                                                        const ecma_value_t arguments_list [], /**< list of arguments
+                                                                                                   passed to routine */
+                                                        ecma_length_t arguments_number) /**< length of
+                                                                                             arguments' list */
+{
+  /* the arguments may be unused for some built-ins */
+  (void) this_arg_value;
+  (void) arguments_list;
+  (void) arguments_number;
+
+  switch (builtin_routine_id)
+  {
+#define ROUTINE_ARG(n) (arguments_number >= n ? arguments_list[n - 1] \
+                                              : ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED))
+#define ROUTINE_ARG_LIST_0
+#define ROUTINE_ARG_LIST_1 , ROUTINE_ARG(1)
+#define ROUTINE_ARG_LIST_2 ROUTINE_ARG_LIST_1, ROUTINE_ARG(2)
+#define ROUTINE_ARG_LIST_3 ROUTINE_ARG_LIST_2, ROUTINE_ARG(3)
+#define ROUTINE_ARG_LIST_NON_FIXED , arguments_list, arguments_number
+#define ROUTINE(name, c_function_name, args_number, length_prop_value) \
+       case name: \
+       { \
+         return c_function_name (this_arg_value ROUTINE_ARG_LIST_ ## args_number); \
+       }
+#include BUILTIN_INC_HEADER_NAME
+#undef ROUTINE_ARG_LIST_0
+#undef ROUTINE_ARG_LIST_1
+#undef ROUTINE_ARG_LIST_2
+#undef ROUTINE_ARG_LIST_3
+#undef ROUTINE_ARG_LIST_NON_FIXED
+
+    default:
+    {
+      JERRY_UNREACHABLE ();
+    }
+  }
+} /* DISPATCH_ROUTINE_ROUTINE_NAME */
+
+#undef PASTE__
+#undef PASTE_
+#undef PASTE
+#undef SORT_PROPERTY_NAMES_ROUTINE_NAME
+#undef DISPATCH_ROUTINE_ROUTINE_NAME
+#undef TRY_TO_INSTANTIATE_PROPERTY_ROUTINE_NAME
+#undef BUILTIN_UNDERSCORED_ID
+#undef BUILTIN_INC_HEADER_NAME
+

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

@@ -0,0 +1,988 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-number-arithmetic.h"
+#include "ecma-objects.h"
+#include "ecma-objects-general.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_MATH_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-math.inc.h"
+#define BUILTIN_UNDERSCORED_ID math
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup object ECMA Object object built-in
+ * @{
+ */
+
+/**
+ * The Math object's 'abs' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.1
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_abs (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (arg_num))
+  {
+    *num_p = arg_num;
+  }
+  else
+  {
+    *num_p = ecma_number_abs (arg_num);
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_abs */
+
+/**
+ * The Math object's 'acos' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_acos (const ecma_value_t& this_arg, /**< 'this' argument */
+                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_math_object_acos */
+
+/**
+ * The Math object's 'asin' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_asin (const ecma_value_t& this_arg, /**< 'this' argument */
+                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_math_object_asin */
+
+/**
+ * The Math object's 'atan' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_atan (const ecma_value_t& this_arg, /**< 'this' argument */
+                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_math_object_atan */
+
+/**
+ * The Math object's 'atan2' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_atan2 (const ecma_value_t& this_arg, /**< 'this' argument */
+                                const ecma_value_t& arg1, /**< first routine's argument */
+                                const ecma_value_t& arg2) /**< second routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_math_object_atan2 */
+
+/**
+ * The Math object's 'ceil' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.6
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_ceil (const ecma_value_t& this_arg, /**< 'this' argument */
+                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_math_object_ceil */
+
+/**
+ * The Math object's 'cos' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.7
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_cos (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (arg_num)
+      || ecma_number_is_infinity (arg_num))
+  {
+    *num_p = ecma_number_make_nan ();
+  }
+  else if (ecma_number_is_zero (arg_num))
+  {
+    *num_p = ECMA_NUMBER_ONE;
+  }
+  else
+  {
+    /* Taylor series of cos (x) around x = 0 is 1 - x^2/2! + x^4/4! - x^6/6! + ... */
+
+    ecma_number_t x = ecma_op_number_remainder (arg_num, 2 * ECMA_NUMBER_PI);
+    ecma_number_t neg_sqr_x = ecma_number_negate (ecma_number_multiply (x, x));
+
+    ecma_number_t sum = ECMA_NUMBER_ZERO;
+    ecma_number_t next_addendum = ECMA_NUMBER_ONE;
+    ecma_number_t next_factorial_factor = ECMA_NUMBER_ZERO;
+
+    ecma_number_t diff = ecma_number_make_infinity (false);
+
+    while ((ecma_number_is_zero (sum) && !ecma_number_is_zero (diff))
+           || (!ecma_number_is_zero (sum)
+               && ecma_number_abs (ecma_number_divide (diff, sum)) > ecma_number_relative_eps))
+    {
+      ecma_number_t next_sum = ecma_number_add (sum, next_addendum);
+
+      next_addendum = ecma_number_multiply (next_addendum, neg_sqr_x);
+      next_factorial_factor = ecma_number_add (next_factorial_factor, ECMA_NUMBER_ONE);
+      next_addendum = ecma_number_divide (next_addendum, next_factorial_factor);
+      next_factorial_factor = ecma_number_add (next_factorial_factor, ECMA_NUMBER_ONE);
+      next_addendum = ecma_number_divide (next_addendum, next_factorial_factor);
+
+      diff = ecma_number_abs (ecma_number_substract (sum, next_sum));
+
+      sum = next_sum;
+    }
+
+    *num_p = sum;
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_cos */
+
+/**
+ * The Math object's 'exp' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.8
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_exp (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (arg_num))
+  {
+    *num_p = arg_num;
+  }
+  else if (ecma_number_is_zero (arg_num))
+  {
+    *num_p = ECMA_NUMBER_ONE;
+  }
+  else if (ecma_number_is_infinity (arg_num))
+  {
+    if (ecma_number_is_negative (arg_num))
+    {
+      *num_p = ECMA_NUMBER_ZERO;
+    }
+    else
+    {
+      *num_p = arg_num;
+    }
+  }
+  else
+  {
+    *num_p = ecma_number_exp (arg_num);
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_exp */
+
+/**
+ * The Math object's 'floor' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.9
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_floor (const ecma_value_t& this_arg, /**< 'this' argument */
+                                const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_math_object_floor */
+
+/**
+ * The Math object's 'log' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.10
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_log (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (arg_num))
+  {
+    *num_p = arg_num;
+  }
+  else if (ecma_number_is_zero (arg_num))
+  {
+    *num_p = ecma_number_make_infinity (true);
+  }
+  else if (ecma_number_is_negative (arg_num))
+  {
+    *num_p = ecma_number_make_nan ();
+  }
+  else if (ecma_number_is_infinity (arg_num))
+  {
+    *num_p = arg_num;
+  }
+  else
+  {
+    *num_p = ecma_number_ln (arg_num);
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_log */
+
+/**
+ * The Math object's 'max' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.11
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_max (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t args[], /**< arguments list */
+                              ecma_length_t args_number) /**< number of arguments */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ecma_number_t ret_num = ecma_number_make_infinity (true);
+
+  bool is_just_convert = false;
+
+  for (ecma_length_t arg_index = 0;
+       arg_index < args_number;
+       arg_index++)
+  {
+    ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, args[arg_index], ret_value);
+
+    if (!is_just_convert)
+    {
+      if (unlikely (ecma_number_is_nan (arg_num)))
+      {
+        ret_num = arg_num;
+        is_just_convert = true;
+      }
+      else if (ecma_number_is_zero (arg_num) /* both numbers are zeroes */
+               && ecma_number_is_zero (ret_num))
+      {
+        if (!ecma_number_is_negative (arg_num))
+        {
+          ret_num = arg_num;
+        }
+      }
+      else if (ecma_number_is_infinity (arg_num))
+      {
+        if (!ecma_number_is_negative (arg_num))
+        {
+          ret_num = arg_num;
+          is_just_convert = true;
+        }
+      }
+      else if (ecma_number_is_infinity (ret_num)) /* ret_num is negative infinity */
+      {
+        JERRY_ASSERT (ecma_number_is_negative (ret_num));
+
+        ret_num = arg_num;
+      }
+      else
+      {
+        JERRY_ASSERT (!ecma_number_is_nan (arg_num)
+                      && !ecma_number_is_infinity (arg_num));
+        JERRY_ASSERT (!ecma_number_is_nan (ret_num)
+                      && !ecma_number_is_infinity (ret_num));
+
+        if (arg_num > ret_num)
+        {
+          ret_num = arg_num;
+        }
+      }
+    }
+
+    ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+    if (ecma_is_completion_value_throw (ret_value))
+    {
+      return ret_value;
+    }
+
+    JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
+  }
+
+  JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+  *num_p = ret_num;
+
+  return ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+} /* ecma_builtin_math_object_max */
+
+/**
+ * The Math object's 'min' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.12
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_min (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t args[], /**< arguments list */
+                              ecma_length_t args_number) /**< number of arguments */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ecma_number_t ret_num = ecma_number_make_infinity (false);
+
+  bool is_just_convert = false;
+
+  for (ecma_length_t arg_index = 0;
+       arg_index < args_number;
+       arg_index++)
+  {
+    ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, args[arg_index], ret_value);
+
+    if (!is_just_convert)
+    {
+      if (unlikely (ecma_number_is_nan (arg_num)))
+      {
+        ret_num = arg_num;
+        is_just_convert = true;
+      }
+      else if (ecma_number_is_zero (arg_num) /* both numbers are zeroes */
+               && ecma_number_is_zero (ret_num))
+      {
+        if (ecma_number_is_negative (arg_num))
+        {
+          ret_num = arg_num;
+        }
+      }
+      else if (ecma_number_is_infinity (arg_num))
+      {
+        if (ecma_number_is_negative (arg_num))
+        {
+          ret_num = arg_num;
+          is_just_convert = true;
+        }
+      }
+      else if (ecma_number_is_infinity (ret_num)) /* ret_num is positive infinity */
+      {
+        JERRY_ASSERT (!ecma_number_is_negative (ret_num));
+
+        ret_num = arg_num;
+      }
+      else
+      {
+        JERRY_ASSERT (!ecma_number_is_nan (arg_num)
+                      && !ecma_number_is_infinity (arg_num));
+        JERRY_ASSERT (!ecma_number_is_nan (ret_num)
+                      && !ecma_number_is_infinity (ret_num));
+
+        if (arg_num < ret_num)
+        {
+          ret_num = arg_num;
+        }
+      }
+    }
+
+    ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+    if (ecma_is_completion_value_throw (ret_value))
+    {
+      return ret_value;
+    }
+
+    JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
+  }
+
+  JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+  *num_p = ret_num;
+
+  return ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+} /* ecma_builtin_math_object_min */
+
+/**
+ * The Math object's 'pow' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.13
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_pow (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t& arg1, /**< first routine's argument */
+                              const ecma_value_t& arg2) /**< second routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (x, arg1, ret_value);
+  ECMA_OP_TO_NUMBER_TRY_CATCH (y, arg2, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (y)
+      || (ecma_number_is_nan (x)
+          && !ecma_number_is_zero (y)))
+  {
+    *num_p = ecma_number_make_nan ();
+  }
+  else if (ecma_number_is_zero (y))
+  {
+    *num_p = ECMA_NUMBER_ONE;
+  }
+  else if (ecma_number_is_infinity (y))
+  {
+    const ecma_number_t x_abs = ecma_number_abs (x);
+
+    if (x_abs == ECMA_NUMBER_ONE)
+    {
+      *num_p = ecma_number_make_nan ();
+    }
+    else if ((ecma_number_is_negative (y) && x_abs < ECMA_NUMBER_ONE)
+             || (!ecma_number_is_negative (y) && x_abs > ECMA_NUMBER_ONE))
+    {
+      *num_p = ecma_number_make_infinity (false);
+    }
+    else
+    {
+      JERRY_ASSERT ((ecma_number_is_negative (y) && x_abs > ECMA_NUMBER_ONE)
+                    || (!ecma_number_is_negative (y) && x_abs < ECMA_NUMBER_ONE));
+
+      *num_p = ECMA_NUMBER_ZERO;
+    }
+  }
+  else
+  {
+    const ecma_number_t diff_is_int = ecma_op_number_remainder (y, ECMA_NUMBER_ONE);
+    const ecma_number_t rel_diff_is_int = ecma_number_abs (ecma_number_divide (diff_is_int,
+                                                                               y));
+    const ecma_number_t y_int = ecma_number_substract (y, diff_is_int);
+
+    const ecma_number_t y_int_half = ecma_number_multiply (y_int, ECMA_NUMBER_HALF);
+    const ecma_number_t diff_is_odd = ecma_op_number_remainder (y_int_half, ECMA_NUMBER_ONE);
+    const ecma_number_t rel_diff_is_odd = ecma_number_abs (ecma_number_divide (diff_is_odd,
+                                                                               y_int_half));
+
+    const bool is_y_int = (rel_diff_is_int < ecma_number_relative_eps);
+    const bool is_y_odd = (is_y_int && rel_diff_is_odd > ecma_number_relative_eps);
+
+    if (ecma_number_is_infinity (x))
+    {
+      if (!ecma_number_is_negative (x))
+      {
+        if (y > ECMA_NUMBER_ZERO)
+        {
+          *num_p = ecma_number_make_infinity (false);
+        }
+        else
+        {
+          JERRY_ASSERT (y < ECMA_NUMBER_ZERO);
+
+          *num_p = ECMA_NUMBER_ZERO;
+        }
+      }
+      else
+      {
+        if (y > ECMA_NUMBER_ZERO)
+        {
+          *num_p = ecma_number_make_infinity (is_y_odd);
+        }
+        else
+        {
+          JERRY_ASSERT (y < ECMA_NUMBER_ZERO);
+
+          if (is_y_odd)
+          {
+            *num_p = ecma_number_negate (ECMA_NUMBER_ZERO);
+          }
+          else
+          {
+            *num_p = ECMA_NUMBER_ZERO;
+          }
+        }
+      }
+    }
+    else if (ecma_number_is_zero (x))
+    {
+      if (!ecma_number_is_negative (x))
+      {
+        if (y > ECMA_NUMBER_ZERO)
+        {
+          *num_p = ECMA_NUMBER_ZERO;
+        }
+        else
+        {
+          JERRY_ASSERT (y < ECMA_NUMBER_ZERO);
+
+          *num_p = ecma_number_make_infinity (false);
+        }
+      }
+      else
+      {
+        if (y > ECMA_NUMBER_ZERO)
+        {
+          if (is_y_odd)
+          {
+            *num_p = ecma_number_negate (ECMA_NUMBER_ZERO);
+          }
+          else
+          {
+            *num_p = ECMA_NUMBER_ZERO;
+          }
+        }
+        else
+        {
+          *num_p = ecma_number_make_infinity (is_y_odd);
+        }
+      }
+    }
+    else if (!ecma_number_is_infinity (x)
+             && x < ECMA_NUMBER_ZERO
+             && !ecma_number_is_infinity (y)
+             && !is_y_int)
+    {
+      *num_p = ecma_number_make_nan ();
+    }
+    else
+    {
+      JERRY_ASSERT (!ecma_number_is_infinity (x)
+                    && !ecma_number_is_zero (x));
+      JERRY_ASSERT (!ecma_number_is_infinity (y)
+                    && !ecma_number_is_zero (y));
+
+      const bool sign = (x < ECMA_NUMBER_ZERO && is_y_odd);
+      const bool invert = (y < ECMA_NUMBER_ZERO);
+
+      JERRY_ASSERT (is_y_int || !sign);
+
+      ecma_number_t positive_x;
+      ecma_number_t positive_y;
+
+      if (x < ECMA_NUMBER_ZERO)
+      {
+        JERRY_ASSERT (x < ECMA_NUMBER_ZERO);
+
+        positive_x = ecma_number_negate (x);
+      }
+      else
+      {
+        positive_x = x;
+      }
+
+      if (invert)
+      {
+        positive_y = ecma_number_negate (y);
+      }
+      else
+      {
+        positive_y = y;
+      }
+
+      ecma_number_t ret_num;
+
+      if (is_y_int
+          && ecma_uint32_to_number (ecma_number_to_uint32 (positive_y)) == positive_y)
+      {
+        TODO (/* Check for license issues */);
+
+        uint32_t power_uint32 = ecma_number_to_uint32 (positive_y);
+
+        ret_num = ECMA_NUMBER_ONE;
+        ecma_number_t power_accumulator = positive_x;
+
+        while (power_uint32 != 0)
+        {
+          if (power_uint32 % 2)
+          {
+            ret_num = ecma_number_multiply (ret_num, power_accumulator);
+
+            power_uint32--;
+          }
+
+          power_accumulator = ecma_number_multiply (power_accumulator, power_accumulator);
+          power_uint32 /= 2;
+        }
+      }
+      else
+      {
+        /* pow (x, y) = exp (y * ln (x)) */
+        ecma_number_t ln_x = ecma_number_ln (positive_x);
+        ecma_number_t y_m_ln_x = ecma_number_multiply (positive_y, ln_x);
+        ret_num = ecma_number_exp (y_m_ln_x);
+      }
+
+      if (sign)
+      {
+        ret_num = ecma_number_negate (ret_num);
+      }
+
+      if (invert)
+      {
+        ret_num = ecma_number_divide (ECMA_NUMBER_ONE, ret_num);
+      }
+
+      *num_p = ret_num;
+    }
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (y);
+  ECMA_OP_TO_NUMBER_FINALIZE (x);
+
+  return ret_value;
+} /* ecma_builtin_math_object_pow */
+
+/**
+ * The Math object's 'random' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.14
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_random (const ecma_value_t& this_arg __attr_unused___) /**< 'this' argument */
+{
+  /* Implementation of George Marsaglia's XorShift random number generator */
+  TODO (/* Check for license issues */);
+
+  static uint32_t word1 = 1455997910;
+  static uint32_t word2 = 1999515274;
+  static uint32_t word3 = 1234451287;
+  static uint32_t word4 = 1949149569;
+
+  uint32_t intermediate = word1 ^ (word1 << 11);
+  intermediate ^= intermediate >> 8;
+
+  word1 = word2;
+  word2 = word3;
+  word3 = word4;
+
+  word4 ^= word4 >> 19;
+  word4 ^= intermediate;
+
+  const uint32_t max_uint32 = (uint32_t) -1;
+  ecma_number_t rand = (ecma_number_t) word4;
+  rand /= (ecma_number_t) max_uint32;
+  rand *= (ecma_number_t) (max_uint32 - 1) / (ecma_number_t) max_uint32;
+
+  ecma_number_t *rand_p = ecma_alloc_number ();
+  *rand_p = rand;
+
+  return ecma_make_normal_completion_value (ecma_make_number_value (rand_p));
+} /* ecma_builtin_math_object_random */
+
+/**
+ * The Math object's 'round' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.15
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_round (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                                const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (arg_num)
+      || ecma_number_is_zero (arg_num)
+      || ecma_number_is_infinity (arg_num))
+  {
+    *num_p = arg_num;
+  }
+  else if (ecma_number_is_negative (arg_num)
+           && arg_num >= -0.5f)
+  {
+    *num_p = ecma_number_negate (0.0f);
+  }
+  else
+  {
+    const ecma_number_t up_half = arg_num + 0.5f;
+    const ecma_number_t down_half = arg_num - 0.5f;
+    const ecma_number_t up_rounded = up_half - ecma_op_number_remainder (up_half, 1);
+    const ecma_number_t down_rounded = down_half - ecma_op_number_remainder (down_half, 1);
+
+    if (up_rounded - arg_num <= arg_num - down_rounded)
+    {
+      *num_p = up_rounded;
+    }
+    else
+    {
+      *num_p = down_rounded;
+    }
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_round */
+
+/**
+ * The Math object's 'sin' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.16
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_sin (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+
+  if (ecma_number_is_nan (arg_num)
+      || ecma_number_is_infinity (arg_num))
+  {
+    *num_p = ecma_number_make_nan ();
+  }
+  else if (ecma_number_is_zero (arg_num))
+  {
+    *num_p = arg_num;
+  }
+  else
+  {
+    /* Taylor series of sin (x) around x = 0 is x - x^3/3! + x^5/5! - x^7/7! + ... */
+
+    ecma_number_t x = ecma_op_number_remainder (arg_num, 2 * ECMA_NUMBER_PI);
+    ecma_number_t neg_sqr_x = ecma_number_negate (ecma_number_multiply (x, x));
+
+    ecma_number_t sum = ECMA_NUMBER_ZERO;
+    ecma_number_t next_addendum = ecma_number_divide (x, ECMA_NUMBER_ONE);
+    ecma_number_t next_factorial_factor = ECMA_NUMBER_ONE;
+
+    ecma_number_t diff = ecma_number_make_infinity (false);
+
+    while ((ecma_number_is_zero (sum) && !ecma_number_is_zero (diff))
+           || (!ecma_number_is_zero (sum)
+               && ecma_number_abs (ecma_number_divide (diff, sum)) > ecma_number_relative_eps))
+    {
+      ecma_number_t next_sum = ecma_number_add (sum, next_addendum);
+
+      next_addendum = ecma_number_multiply (next_addendum, neg_sqr_x);
+      next_factorial_factor = ecma_number_add (next_factorial_factor, ECMA_NUMBER_ONE);
+      next_addendum = ecma_number_divide (next_addendum, next_factorial_factor);
+      next_factorial_factor = ecma_number_add (next_factorial_factor, ECMA_NUMBER_ONE);
+      next_addendum = ecma_number_divide (next_addendum, next_factorial_factor);
+
+      diff = ecma_number_abs (ecma_number_substract (sum, next_sum));
+
+      sum = next_sum;
+    }
+
+    *num_p = sum;
+  }
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_sin */
+
+/**
+ * The Math object's 'sqrt' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.17
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_sqrt (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, arg, ret_value);
+
+  ecma_number_t ret_num;
+
+  if (ecma_number_is_nan (arg_num)
+      || (!ecma_number_is_zero (arg_num)
+          && ecma_number_is_negative (arg_num)))
+  {
+    ret_num = ecma_number_make_nan ();
+  }
+  else if (ecma_number_is_zero (arg_num))
+  {
+    ret_num = arg_num;
+  }
+  else if (ecma_number_is_infinity (arg_num))
+  {
+    JERRY_ASSERT (!ecma_number_is_negative (arg_num));
+
+    ret_num = arg_num;
+  }
+  else
+  {
+    ret_num = ecma_number_sqrt (arg_num);
+  }
+
+  ecma_number_t *num_p = ecma_alloc_number ();
+  *num_p = ret_num;
+
+  ret_value = ecma_make_normal_completion_value (ecma_make_number_value (num_p));
+
+  ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+  return ret_value;
+} /* ecma_builtin_math_object_sqrt */
+
+/**
+ * The Math object's 'tan' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.8.2.18
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_math_object_tan (const ecma_value_t& this_arg, /**< 'this' argument */
+                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_math_object_tan */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_MATH_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-math.inc.h

@@ -0,0 +1,129 @@
+/* Copyright 2014 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.
+ */
+
+/*
+ * Math built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef SIMPLE_VALUE
+# define SIMPLE_VALUE(name, simple_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !SIMPLE_VALUE */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_MATH)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// ECMA-262 v5, 15.8.1.1
+NUMBER_VALUE (ECMA_MAGIC_STRING_E_U,
+              ECMA_NUMBER_E,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.2
+NUMBER_VALUE (ECMA_MAGIC_STRING_LN10_U,
+              ECMA_NUMBER_LN10,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LN2_U,
+              ECMA_NUMBER_LN2,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.4
+NUMBER_VALUE (ECMA_MAGIC_STRING_LOG2E_U,
+              ECMA_NUMBER_LOG2E,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.5
+NUMBER_VALUE (ECMA_MAGIC_STRING_LOG10E_U,
+              ECMA_NUMBER_LOG10E,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.6
+NUMBER_VALUE (ECMA_MAGIC_STRING_PI_U,
+              ECMA_NUMBER_PI,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.7
+NUMBER_VALUE (ECMA_MAGIC_STRING_SQRT1_2_U,
+              ECMA_NUMBER_SQRT_1_2,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// ECMA-262 v5, 15.8.1.8
+NUMBER_VALUE (ECMA_MAGIC_STRING_SQRT2_U,
+              ECMA_NUMBER_SQRT2,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_ABS, ecma_builtin_math_object_abs, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_ACOS, ecma_builtin_math_object_acos, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_ASIN, ecma_builtin_math_object_asin, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_ATAN, ecma_builtin_math_object_atan, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_ATAN2, ecma_builtin_math_object_atan2, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_CEIL, ecma_builtin_math_object_ceil, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_COS, ecma_builtin_math_object_cos, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_EXP, ecma_builtin_math_object_exp, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_FLOOR, ecma_builtin_math_object_floor, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_LOG, ecma_builtin_math_object_log, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_MAX, ecma_builtin_math_object_max, NON_FIXED, 2)
+ROUTINE (ECMA_MAGIC_STRING_MIN, ecma_builtin_math_object_min, NON_FIXED, 2)
+ROUTINE (ECMA_MAGIC_STRING_POW, ecma_builtin_math_object_pow, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_RANDOM, ecma_builtin_math_object_random, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_ROUND, ecma_builtin_math_object_round, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_SIN, ecma_builtin_math_object_sin, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_SQRT, ecma_builtin_math_object_sqrt, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_TAN, ecma_builtin_math_object_tan, 1, 1)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.cpp

@@ -0,0 +1,214 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-number-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID number_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup numberprototype ECMA Number.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Number.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.7.4.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_number_prototype_object_to_string (const ecma_value_t& this_arg, /**< this argument */
+                                                const ecma_value_t* arguments_list_p, /**< arguments list */
+                                                ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  ecma_number_t this_arg_number;
+
+  if (ecma_is_value_number (this_arg))
+  {
+    ecma_number_t *this_arg_number_p = ecma_get_number_from_value (this_arg);
+
+    this_arg_number = *this_arg_number_p;
+  }
+  else if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+
+    ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
+
+    if (class_prop_p->u.internal_property.value == ECMA_MAGIC_STRING_NUMBER_UL)
+    {
+      ecma_property_t *prim_value_prop_p = ecma_get_internal_property (obj_p,
+                                                                       ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
+
+      ecma_number_t *prim_value_num_p = ECMA_GET_NON_NULL_POINTER (ecma_number_t,
+                                                                   prim_value_prop_p->u.internal_property.value);
+      this_arg_number = *prim_value_num_p;
+    }
+    else
+    {
+      return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+    }
+  }
+  else
+  {
+    return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+  }
+
+  if (arguments_list_len == 0)
+  {
+    ecma_string_t *ret_str_p = ecma_new_ecma_string_from_number (this_arg_number);
+
+    return ecma_make_normal_completion_value (ecma_make_string_value (ret_str_p));
+  }
+  {
+    ECMA_BUILTIN_CP_UNIMPLEMENTED (arguments_list_p);
+  }
+} /* ecma_builtin_number_prototype_object_to_string */
+
+/**
+ * The Number.prototype object's 'toLocaleString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.7.4.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_number_prototype_object_to_locale_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  return ecma_builtin_number_prototype_object_to_string (this_arg, NULL, 0);
+} /* ecma_builtin_number_prototype_object_to_locale_string */
+
+/**
+ * The Number.prototype object's 'valueOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.7.4.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_number_prototype_object_value_of (const ecma_value_t& this_arg) /**< this argument */
+{
+  if (ecma_is_value_number (this_arg))
+  {
+    return ecma_make_normal_completion_value (ecma_copy_value (this_arg, true));
+  }
+  else if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+
+    ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
+
+    if (class_prop_p->u.internal_property.value == ECMA_MAGIC_STRING_NUMBER_UL)
+    {
+      ecma_property_t *prim_value_prop_p = ecma_get_internal_property (obj_p,
+                                                                       ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
+
+      ecma_number_t *prim_value_num_p = ECMA_GET_NON_NULL_POINTER (ecma_number_t,
+                                                                   prim_value_prop_p->u.internal_property.value);
+
+      ecma_number_t *ret_num_p = ecma_alloc_number ();
+      *ret_num_p = *prim_value_num_p;
+
+      return ecma_make_normal_completion_value (ecma_make_number_value (ret_num_p));
+    }
+  }
+
+  return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+} /* ecma_builtin_number_prototype_object_value_of */
+
+/**
+ * The Number.prototype object's 'toFixed' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.7.4.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_number_prototype_object_to_fixed (const ecma_value_t& this_arg, /**< this argument */
+                                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_number_prototype_object_to_fixed */
+
+/**
+ * The Number.prototype object's 'toExponential' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.7.4.6
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_number_prototype_object_to_exponential (const ecma_value_t& this_arg, /**< this argument */
+                                                     const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_number_prototype_object_to_exponential */
+
+/**
+ * The Number.prototype object's 'toPrecision' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.7.4.7
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_number_prototype_object_to_precision (const ecma_value_t& this_arg, /**< this argument */
+                                                   const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_number_prototype_object_to_precision */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-number-prototype.inc.h

@@ -0,0 +1,60 @@
+/* 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.
+ */
+
+/*
+ * Number.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_NUMBER_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.7.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_NUMBER),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_number_prototype_object_to_string, NON_FIXED, 1)
+ROUTINE (ECMA_MAGIC_STRING_VALUE_OF_UL, ecma_builtin_number_prototype_object_value_of, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TO_LOCALE_STRING_UL, ecma_builtin_number_prototype_object_to_locale_string, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TO_FIXED_UL, ecma_builtin_number_prototype_object_to_fixed, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_TO_EXPONENTIAL_UL, ecma_builtin_number_prototype_object_to_exponential, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_TO_PRECISION_UL, ecma_builtin_number_prototype_object_to_precision, 1, 1)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,109 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-number-object.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-number.inc.h"
+#define BUILTIN_UNDERSCORED_ID number
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup number ECMA Number object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Number object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_number_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                   ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_completion_value_t ret_value;
+
+  if (arguments_list_len == 0)
+  {
+    ecma_number_t *zero_num_p = ecma_alloc_number ();
+    *zero_num_p = ECMA_NUMBER_ZERO;
+
+    ret_value = ecma_make_normal_completion_value (ecma_make_number_value (zero_num_p));
+  }
+  else
+  {
+    ret_value = ecma_op_to_number (arguments_list_p [0]);
+  }
+
+  return ret_value;
+} /* ecma_builtin_number_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Number object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_number_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                        ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len == 0)
+  {
+    ecma_number_t *zero_num_p = ecma_alloc_number ();
+    *zero_num_p = ECMA_NUMBER_ZERO;
+
+    ecma_completion_value_t completion = ecma_op_create_number_object (ecma_make_number_value (zero_num_p));
+
+    ecma_dealloc_number (zero_num_p);
+
+    return completion;
+  }
+  else
+  {
+    return ecma_op_create_number_object (arguments_list_p[0]);
+  }
+} /* ecma_builtin_number_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-number.inc.h

@@ -0,0 +1,96 @@
+/* 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.
+ */
+
+/*
+ * Number built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_NUMBER)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.7.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// 15.7.3.4
+NUMBER_VALUE (ECMA_MAGIC_STRING_NAN,
+              ecma_number_make_nan (),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// 15.7.3.2
+NUMBER_VALUE (ECMA_MAGIC_STRING_MAX_VALUE_U,
+              ECMA_NUMBER_MAX_VALUE,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// 15.7.3.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_MIN_VALUE_U,
+              ECMA_NUMBER_MIN_VALUE,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// 15.7.3.5
+NUMBER_VALUE (ECMA_MAGIC_STRING_POSITIVE_INFINITY_U,
+              ecma_number_make_infinity (false),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+// 15.7.3.6
+NUMBER_VALUE (ECMA_MAGIC_STRING_NEGATIVE_INFINITY_U,
+              ecma_number_make_infinity (true),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.7.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_NUMBER_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-object-prototype.cpp

@@ -0,0 +1,215 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-object-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID object_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup objectprototype ECMA Object.prototype object built-in
+ * @{
+ */
+
+/**
+ * The Object.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.4.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_prototype_object_to_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  ecma_magic_string_id_t type_string;
+
+  if (ecma_is_value_undefined (this_arg))
+  {
+    type_string = ECMA_MAGIC_STRING_UNDEFINED_UL;
+  }
+  else if (ecma_is_value_null (this_arg))
+  {
+    type_string = ECMA_MAGIC_STRING_NULL_UL;
+  }
+  else
+  {
+    ecma_completion_value_t obj_this = ecma_op_to_object (this_arg);
+
+    if (!ecma_is_completion_value_normal (obj_this))
+    {
+      return obj_this;
+    }
+
+    JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (obj_this)));
+
+    ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_this);
+
+    ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p,
+                                                                ECMA_INTERNAL_PROPERTY_CLASS);
+    type_string = (ecma_magic_string_id_t) class_prop_p->u.internal_property.value;
+
+    ecma_free_completion_value (obj_this);
+  }
+
+  ecma_string_t *ret_string_p;
+
+  /* Building string "[object #type#]" where type is 'Undefined',
+     'Null' or one of possible object's classes.
+     The string with null character is maximum 19 characters long. */
+  const ssize_t buffer_size = 19;
+  MEM_DEFINE_LOCAL_ARRAY (str_buffer, buffer_size, ecma_char_t);
+
+  const ecma_char_t *left_square_zt_str_p = ecma_get_magic_string_zt (ECMA_MAGIC_STRING_LEFT_SQUARE_CHAR);
+  const ecma_char_t *object_zt_str_p = ecma_get_magic_string_zt (ECMA_MAGIC_STRING_OBJECT);
+  const ecma_char_t *space_zt_str_p = ecma_get_magic_string_zt (ECMA_MAGIC_STRING_SPACE_CHAR);
+  const ecma_char_t *type_name_zt_str_p = ecma_get_magic_string_zt (type_string);
+  const ecma_char_t *right_square_zt_str_p = ecma_get_magic_string_zt (ECMA_MAGIC_STRING_RIGHT_SQUARE_CHAR);
+
+  ecma_char_t *buffer_ptr = str_buffer;
+  ssize_t buffer_size_left = buffer_size;
+  buffer_ptr = ecma_copy_zt_string_to_buffer (left_square_zt_str_p,
+                                              buffer_ptr,
+                                              buffer_size_left);
+  buffer_size_left = buffer_size - (buffer_ptr - str_buffer) * (ssize_t) sizeof (ecma_char_t);
+  buffer_ptr = ecma_copy_zt_string_to_buffer (object_zt_str_p,
+                                              buffer_ptr,
+                                              buffer_size_left);
+  buffer_size_left = buffer_size - (buffer_ptr - str_buffer) * (ssize_t) sizeof (ecma_char_t);
+  buffer_ptr = ecma_copy_zt_string_to_buffer (space_zt_str_p,
+                                              buffer_ptr,
+                                              buffer_size_left);
+  buffer_size_left = buffer_size - (buffer_ptr - str_buffer) * (ssize_t) sizeof (ecma_char_t);
+  buffer_ptr = ecma_copy_zt_string_to_buffer (type_name_zt_str_p,
+                                              buffer_ptr,
+                                              buffer_size_left);
+  buffer_size_left = buffer_size - (buffer_ptr - str_buffer) * (ssize_t) sizeof (ecma_char_t);
+  buffer_ptr = ecma_copy_zt_string_to_buffer (right_square_zt_str_p,
+                                              buffer_ptr,
+                                              buffer_size_left);
+  buffer_size_left = buffer_size - (buffer_ptr - str_buffer) * (ssize_t) sizeof (ecma_char_t);
+
+  JERRY_ASSERT (buffer_size_left >= 0);
+
+  ret_string_p = ecma_new_ecma_string (str_buffer);
+
+  MEM_FINALIZE_LOCAL_ARRAY (str_buffer);
+
+  return ecma_make_normal_completion_value (ecma_make_string_value (ret_string_p));
+} /* ecma_builtin_object_prototype_object_to_string */
+
+/**
+ * The Object.prototype object's 'valueOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.4.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_prototype_object_value_of (const ecma_value_t& this_arg) /**< this argument */
+{
+  return ecma_op_to_object (this_arg);
+} /* ecma_builtin_object_prototype_object_value_of */
+
+/**
+ * The Object.prototype object's 'toLocaleString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.4.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_prototype_object_to_locale_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_object_prototype_object_to_locale_string */
+
+/**
+ * The Object.prototype object's 'hasOwnProperty' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.4.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_prototype_object_has_own_property (const ecma_value_t& this_arg, /**< this argument */
+                                                       const ecma_value_t& arg) /**< first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_prototype_object_has_own_property */
+
+/**
+ * The Object.prototype object's 'isPrototypeOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.4.6
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_prototype_object_is_prototype_of (const ecma_value_t& this_arg, /**< this argument */
+                                                      const ecma_value_t& arg) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_prototype_object_is_prototype_of */
+
+/**
+ * The Object.prototype object's 'propertyIsEnumerable' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.4.7
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_prototype_object_property_is_enumerable (const ecma_value_t& this_arg, /**< this argument */
+                                                             const ecma_value_t& arg) /**< routine's first argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_prototype_object_property_is_enumerable */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtin-object-prototype.inc.h

@@ -0,0 +1,60 @@
+/* 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.
+ */
+
+/*
+ * Object.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.2.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_object_prototype_object_to_string, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_VALUE_OF_UL, ecma_builtin_object_prototype_object_value_of, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TO_LOCALE_STRING_UL, ecma_builtin_object_prototype_object_to_locale_string, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_HAS_OWN_PROPERTY_UL, ecma_builtin_object_prototype_object_has_own_property, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_IS_PROTOTYPE_OF_UL, ecma_builtin_object_prototype_object_is_prototype_of, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_PROPERTY_IS_ENUMERABLE_UL, ecma_builtin_object_prototype_object_property_is_enumerable, 1, 1)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,358 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-objects-general.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-object.inc.h"
+#define BUILTIN_UNDERSCORED_ID object
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup object ECMA Object object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in Object object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_object_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                   ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_completion_value_t ret_value;
+
+  if (arguments_list_len == 0
+      || ecma_is_value_undefined (arguments_list_p[0])
+      || ecma_is_value_null (arguments_list_p [0]))
+  {
+    ret_value = ecma_builtin_object_dispatch_construct (arguments_list_p, arguments_list_len);
+  }
+  else
+  {
+    ret_value = ecma_op_to_object (arguments_list_p [0]);
+  }
+
+  return ret_value;
+} /* ecma_builtin_object_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in Object object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_object_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                        ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len == 0)
+  {
+    ecma_object_t *obj_p = ecma_op_create_object_object_noarg ();
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
+  }
+  else
+  {
+    ecma_completion_value_t new_obj_value = ecma_op_create_object_object_arg (arguments_list_p [0]);
+
+    if (!ecma_is_completion_value_normal (new_obj_value))
+    {
+      return new_obj_value;
+    }
+    else
+    {
+      return ecma_make_normal_completion_value (ecma_get_completion_value_value (new_obj_value));
+    }
+  }
+} /* ecma_builtin_object_dispatch_construct */
+
+/**
+ * The Object object's 'getPrototypeOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_get_prototype_of (const ecma_value_t& this_arg, /**< 'this' argument */
+                                             const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_get_prototype_of */
+
+/**
+ * The Object object's 'getOwnPropertyNames' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_get_own_property_names (const ecma_value_t& this_arg, /**< 'this' argument */
+                                                   const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_get_own_property_names */
+
+/**
+ * The Object object's 'seal' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.8
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_seal (const ecma_value_t& this_arg, /**< 'this' argument */
+                                 const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_seal */
+
+/**
+ * The Object object's 'freeze' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.9
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_freeze (const ecma_value_t& this_arg, /**< 'this' argument */
+                                   const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_freeze */
+
+/**
+ * The Object object's 'preventExtensions' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.10
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_prevent_extensions (const ecma_value_t& this_arg, /**< 'this' argument */
+                                               const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_prevent_extensions */
+
+/**
+ * The Object object's 'isSealed' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.11
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_is_sealed (const ecma_value_t& this_arg, /**< 'this' argument */
+                                      const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_is_sealed */
+
+/**
+ * The Object object's 'isFrozen' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.12
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_is_frozen (const ecma_value_t& this_arg, /**< 'this' argument */
+                                      const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_is_frozen */
+
+/**
+ * The Object object's 'isExtensible' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.13
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_is_extensible (const ecma_value_t& this_arg, /**< 'this' argument */
+                                          const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_is_extensible */
+
+/**
+ * The Object object's 'keys' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.14
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_keys (const ecma_value_t& this_arg, /**< 'this' argument */
+                                 const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_object_object_keys */
+
+/**
+ * The Object object's 'getOwnPropertyDescriptor' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_get_own_property_descriptor (const ecma_value_t& this_arg, /**< 'this' argument */
+                                                        const ecma_value_t& arg1, /**< routine's first argument */
+                                                        const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_object_object_get_own_property_descriptor */
+
+/**
+ * The Object object's 'create' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_create (const ecma_value_t& this_arg, /**< 'this' argument */
+                                   const ecma_value_t& arg1, /**< routine's first argument */
+                                   const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_object_object_create */
+
+/**
+ * The Object object's 'defineProperties' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.7
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_define_properties (const ecma_value_t& this_arg, /**< 'this' argument */
+                                              const ecma_value_t& arg1, /**< routine's first argument */
+                                              const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_object_object_define_properties */
+
+/**
+ * The Object object's 'defineProperty' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.2.3.6
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_object_object_define_property (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                                            const ecma_value_t& arg1, /**< routine's first argument */
+                                            const ecma_value_t& arg2, /**< routine's second argument */
+                                            const ecma_value_t& arg3) /**< routine's third argument */
+{
+  ecma_completion_value_t ret_value;
+
+  if (!ecma_is_value_object (arg1))
+  {
+    ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+  }
+  else
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (arg1);
+
+    ECMA_TRY_CATCH (name_str_value,
+                    ecma_op_to_string (arg2),
+                    ret_value);
+
+    ecma_string_t *name_str_p = ecma_get_string_from_value (name_str_value);
+
+    ecma_property_descriptor_t prop_desc;
+
+    ECMA_TRY_CATCH (conv_result,
+                    ecma_op_to_property_descriptor (arg3, &prop_desc),
+                    ret_value);
+
+    ECMA_TRY_CATCH (define_own_prop_ret,
+                    ecma_op_object_define_own_property (obj_p,
+                                                        name_str_p,
+                                                        &prop_desc,
+                                                        true),
+                    ret_value);
+
+    ret_value = ecma_make_normal_completion_value (ecma_copy_value (arg1, true));
+
+    ECMA_FINALIZE (define_own_prop_ret);
+    ecma_free_property_descriptor (&prop_desc);
+    ECMA_FINALIZE (conv_result);
+    ECMA_FINALIZE (name_str_value);
+  }
+
+  return ret_value;
+} /* ecma_builtin_object_object_define_property */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtin-object.inc.h

@@ -0,0 +1,81 @@
+/* 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.
+ */
+
+/*
+ * Object built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_OBJECT)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.2.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.2.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_GET_PROTOTYPE_OF_UL, ecma_builtin_object_object_get_prototype_of, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_GET_OWN_PROPERTY_NAMES_UL, ecma_builtin_object_object_get_own_property_names, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_SEAL, ecma_builtin_object_object_seal, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_FREEZE, ecma_builtin_object_object_freeze, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_PREVENT_EXTENSIONS_UL, ecma_builtin_object_object_prevent_extensions, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_IS_SEALED_UL, ecma_builtin_object_object_is_sealed, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_IS_FROZEN_UL, ecma_builtin_object_object_is_frozen, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_IS_EXTENSIBLE, ecma_builtin_object_object_is_extensible, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_KEYS, ecma_builtin_object_object_keys, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_GET_OWN_PROPERTY_DESCRIPTOR_UL, ecma_builtin_object_object_get_own_property_descriptor, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_CREATE, ecma_builtin_object_object_create, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_DEFINE_PROPERTIES_UL, ecma_builtin_object_object_define_properties, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_DEFINE_PROPERTY_UL, ecma_builtin_object_object_define_property, 3, 3)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-rangeerror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-rangeerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID range_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-rangeerror-prototype.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * RangeError.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_RANGE_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.7.8
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_RANGE_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.9
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_RANGE_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.10
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-rangeerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID range_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup rangeerror ECMA RangeError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in RangeError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_range_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                        ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_RANGE,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_RANGE);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_range_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in RangeError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_range_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                             ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_range_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_range_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-rangeerror.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * RangeError built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_RANGE_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_RANGE_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-referenceerror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-referenceerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID reference_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-referenceerror-prototype.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * ReferenceError.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_REFERENCE_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.7.8
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_REFERENCE_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.9
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_REFERENCE_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.10
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-referenceerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID reference_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup referenceerror ECMA ReferenceError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in ReferenceError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_reference_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                            ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_REFERENCE,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_REFERENCE);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_reference_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in ReferenceError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_reference_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                 ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_reference_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_reference_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-referenceerror.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * ReferenceError built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_REFERENCE_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_REFERENCE_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.cpp

@@ -0,0 +1,381 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-string-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID string_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup stringprototype ECMA String.prototype object built-in
+ * @{
+ */
+
+/**
+ * The String.prototype object's 'toString' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_to_string (const ecma_value_t& this_arg) /**< this argument */
+{
+  if (ecma_is_value_string (this_arg))
+  {
+    return ecma_make_normal_completion_value (ecma_copy_value (this_arg, true));
+  }
+  else if (ecma_is_value_object (this_arg))
+  {
+    ecma_object_t *obj_p = ecma_get_object_from_value (this_arg);
+
+    ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
+
+    if (class_prop_p->u.internal_property.value == ECMA_MAGIC_STRING_STRING_UL)
+    {
+      ecma_property_t *prim_value_prop_p = ecma_get_internal_property (obj_p,
+                                                                       ECMA_INTERNAL_PROPERTY_PRIMITIVE_STRING_VALUE);
+
+      ecma_string_t *prim_value_str_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t,
+                                                                   prim_value_prop_p->u.internal_property.value);
+
+      prim_value_str_p = ecma_copy_or_ref_ecma_string (prim_value_str_p);
+
+      return ecma_make_normal_completion_value (ecma_make_string_value (prim_value_str_p));
+    }
+  }
+
+  return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+} /* ecma_builtin_string_prototype_object_to_string */
+
+/**
+ * The String.prototype object's 'valueOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.3
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_value_of (const ecma_value_t& this_arg) /**< this argument */
+{
+  return ecma_builtin_string_prototype_object_to_string (this_arg);
+} /* ecma_builtin_string_prototype_object_value_of */
+
+/**
+ * The String.prototype object's 'charAt' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.4
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_char_at (const ecma_value_t& this_arg, /**< this argument */
+                                              const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_string_prototype_object_char_at */
+
+/**
+ * The String.prototype object's 'charCodeAt' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.5
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_char_code_at (const ecma_value_t& this_arg, /**< this argument */
+                                                   const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_string_prototype_object_char_code_at */
+
+/**
+ * The String.prototype object's 'concat' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.6
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_concat (const ecma_value_t& this_arg, /**< this argument */
+                                             const ecma_value_t* argument_list_p, /**< arguments list */
+                                             ecma_length_t arguments_number) /**< number of arguments */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, argument_list_p, arguments_number);
+} /* ecma_builtin_string_prototype_object_concat */
+
+/**
+ * The String.prototype object's 'indexOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.7
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_index_of (const ecma_value_t& this_arg, /**< this argument */
+                                               const ecma_value_t& arg1, /**< routine's first argument */
+                                               const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_string_prototype_object_index_of */
+
+/**
+ * The String.prototype object's 'lastIndexOf' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.8
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_last_index_of (const ecma_value_t& this_arg, /**< this argument */
+                                                    const ecma_value_t& arg1, /**< routine's first argument */
+                                                    const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_string_prototype_object_last_index_of */
+
+/**
+ * The String.prototype object's 'localeCompare' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.9
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_locale_compare (const ecma_value_t& this_arg, /**< this argument */
+                                                     const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_string_prototype_object_locale_compare */
+
+/**
+ * The String.prototype object's 'match' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.10
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_match (const ecma_value_t& this_arg, /**< this argument */
+                                            const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_string_prototype_object_match */
+
+/**
+ * The String.prototype object's 'replace' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.11
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_replace (const ecma_value_t& this_arg, /**< this argument */
+                                              const ecma_value_t& arg1, /**< routine's first argument */
+                                              const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_string_prototype_object_replace */
+
+/**
+ * The String.prototype object's 'search' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.12
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_search (const ecma_value_t& this_arg, /**< this argument */
+                                             const ecma_value_t& arg) /**< routine's argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg);
+} /* ecma_builtin_string_prototype_object_search */
+
+/**
+ * The String.prototype object's 'slice' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.13
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_slice (const ecma_value_t& this_arg, /**< this argument */
+                                            const ecma_value_t& arg1, /**< routine's first argument */
+                                            const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_string_prototype_object_slice */
+
+/**
+ * The String.prototype object's 'split' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.14
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_split (const ecma_value_t& this_arg, /**< this argument */
+                                            const ecma_value_t& arg1, /**< routine's first argument */
+                                            const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_string_prototype_object_split */
+
+/**
+ * The String.prototype object's 'substring' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.15
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_substring (const ecma_value_t& this_arg, /**< this argument */
+                                                const ecma_value_t& arg1, /**< routine's first argument */
+                                                const ecma_value_t& arg2) /**< routine's second argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg, arg1, arg2);
+} /* ecma_builtin_string_prototype_object_substring */
+
+/**
+ * The String.prototype object's 'toLowerCase' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.16
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_to_lower_case (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_string_prototype_object_to_lower_case */
+
+/**
+ * The String.prototype object's 'toLocaleLowerCase' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.17
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_to_locale_lower_case (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_string_prototype_object_to_locale_lower_case */
+
+/**
+ * The String.prototype object's 'toUpperCase' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.18
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_to_upper_case (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_string_prototype_object_to_upper_case */
+
+/**
+ * The String.prototype object's 'toLocaleUpperCase' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.19
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_to_locale_upper_case (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_string_prototype_object_to_locale_upper_case */
+
+/**
+ * The String.prototype object's 'trim' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.4.20
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_prototype_object_trim (const ecma_value_t& this_arg) /**< this argument */
+{
+  ECMA_BUILTIN_CP_UNIMPLEMENTED (this_arg);
+} /* ecma_builtin_string_prototype_object_trim */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.inc.h

@@ -0,0 +1,73 @@
+/* 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.
+ */
+
+/*
+ * String.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_STRING_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.5.4.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_STRING),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_TO_STRING_UL, ecma_builtin_string_prototype_object_to_string, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_VALUE_OF_UL, ecma_builtin_string_prototype_object_value_of, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_CONCAT, ecma_builtin_string_prototype_object_concat, NON_FIXED, 1)
+ROUTINE (ECMA_MAGIC_STRING_SLICE, ecma_builtin_string_prototype_object_slice, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_INDEX_OF_UL, ecma_builtin_string_prototype_object_index_of, 2, 1)
+ROUTINE (ECMA_MAGIC_STRING_LAST_INDEX_OF_UL, ecma_builtin_string_prototype_object_last_index_of, 2, 1)
+ROUTINE (ECMA_MAGIC_STRING_CHAR_AT_UL, ecma_builtin_string_prototype_object_char_at, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_CHAR_CODE_AT_UL, ecma_builtin_string_prototype_object_char_code_at, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_LOCALE_COMPARE_UL, ecma_builtin_string_prototype_object_locale_compare, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_MATCH, ecma_builtin_string_prototype_object_match, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_REPLACE, ecma_builtin_string_prototype_object_replace, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_SEARCH, ecma_builtin_string_prototype_object_search, 1, 1)
+ROUTINE (ECMA_MAGIC_STRING_SPLIT, ecma_builtin_string_prototype_object_split, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_SUBSTRING, ecma_builtin_string_prototype_object_substring, 2, 2)
+ROUTINE (ECMA_MAGIC_STRING_TO_LOWER_CASE_UL, ecma_builtin_string_prototype_object_to_lower_case, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TO_LOCALE_LOWER_CASE_UL, ecma_builtin_string_prototype_object_to_locale_lower_case, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TO_UPPER_CASE_UL, ecma_builtin_string_prototype_object_to_upper_case, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TO_LOCALE_UPPER_CASE_UL, ecma_builtin_string_prototype_object_to_locale_upper_case, 0, 0)
+ROUTINE (ECMA_MAGIC_STRING_TRIM, ecma_builtin_string_prototype_object_trim, 0, 0)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,158 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-string.inc.h"
+#define BUILTIN_UNDERSCORED_ID string
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup string ECMA String object built-in
+ * @{
+ */
+
+/**
+ * The String object's 'fromCharCode' routine
+ *
+ * See also:
+ *          ECMA-262 v5, 15.5.3.2
+ *
+ * @return completion value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_string_object_from_char_code (const ecma_value_t& this_arg __attr_unused___, /**< 'this' argument */
+                                           const ecma_value_t args[], /**< arguments list */
+                                           ecma_length_t args_number) /**< number of arguments */
+{
+  ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
+
+  size_t zt_str_buffer_size = sizeof (ecma_char_t) * (args_number + 1u);
+
+  ecma_char_t *ret_zt_str_p = (ecma_char_t*) mem_heap_alloc_block (zt_str_buffer_size,
+                                                                   MEM_HEAP_ALLOC_SHORT_TERM);
+  ret_zt_str_p [args_number] = ECMA_CHAR_NULL;
+
+  for (ecma_length_t arg_index = 0;
+       arg_index < args_number;
+       arg_index++)
+  {
+    ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, args[arg_index], ret_value);
+
+    uint32_t uint32_char_code = ecma_number_to_uint32 (arg_num);
+    uint16_t uint16_char_code = (uint16_t) uint32_char_code;
+
+#if CONFIG_ECMA_CHAR_ENCODING == CONFIG_ECMA_CHAR_ASCII
+    if ((uint16_char_code >> JERRY_BITSINBYTE) != 0)
+    {
+      ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+    }
+    else
+    {
+      ret_zt_str_p [arg_index] = (ecma_char_t) uint16_char_code;
+    }
+#elif CONFIG_ECMA_CHAR_ENCODING == CONFIG_ECMA_CHAR_UTF16
+    ret_zt_str_p [arg_index] = (ecma_char_t) uint16_char_code;
+#endif /* CONFIG_ECMA_CHAR_ENCODING == CONFIG_ECMA_CHAR_UTF16 */
+
+    ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
+
+    if (ecma_is_completion_value_throw (ret_value))
+    {
+      mem_heap_free_block (ret_zt_str_p);
+
+      return ret_value;
+    }
+
+    JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
+  }
+
+  ecma_string_t *ret_str_p = ecma_new_ecma_string (ret_zt_str_p);
+
+  mem_heap_free_block (ret_zt_str_p);
+
+  return ecma_make_normal_completion_value (ecma_make_string_value (ret_str_p));
+} /* ecma_builtin_string_object_from_char_code */
+
+/**
+ * Handle calling [[Call]] of built-in String object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_string_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                   ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_completion_value_t ret_value;
+
+  if (arguments_list_len == 0)
+  {
+    ecma_string_t *str_p = ecma_new_ecma_string_from_magic_string_id (ECMA_MAGIC_STRING__EMPTY);
+    ecma_value_t str_value = ecma_make_string_value (str_p);
+
+    ret_value = ecma_make_normal_completion_value (str_value);
+  }
+  else
+  {
+    ret_value = ecma_op_to_string (arguments_list_p [0]);
+  }
+
+  return ret_value;
+} /* ecma_builtin_string_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in String object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_string_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                        ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  return ecma_op_create_string_object (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_string_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */

jerry-core/ecma/builtin-objects/ecma-builtin-string.inc.h

@@ -0,0 +1,69 @@
+/* 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.
+ */
+
+/*
+ * String built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+#ifndef ROUTINE
+# define ROUTINE(name, c_function_name, args_number, length_prop_value)
+#endif /* !ROUTINE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_STRING)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.5.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.7.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_STRING_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Routine properties:
+ *  (property name, C routine name, arguments number or NON_FIXED, value of the routine's length property) */
+ROUTINE (ECMA_MAGIC_STRING_FROM_CHAR_CODE_UL, ecma_builtin_string_object_from_char_code, NON_FIXED, 1)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-syntaxerror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-syntaxerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID syntax_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-syntaxerror-prototype.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * SyntaxError.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_SYNTAX_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.7.8
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_SYNTAX_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.9
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_SYNTAX_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.10
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-syntaxerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID syntax_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup syntaxerror ECMA SyntaxError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in SyntaxError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_syntax_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                         ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_SYNTAX,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_SYNTAX);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_syntax_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in SyntaxError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_syntax_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                              ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_syntax_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_syntax_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-syntaxerror.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * SyntaxError built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_SYNTAX_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_SYNTAX_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-type-error-thrower.cpp

@@ -0,0 +1,84 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-type-error-thrower.inc.h"
+#define BUILTIN_UNDERSCORED_ID type_error_thrower
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup type_error_thrower ECMA [[ThrowTypeError]] object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in [[ThrowTypeError]] object
+ *
+ * See also:
+ *          ECMA-262 v5, 13.2.3
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_type_error_thrower_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                               ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  /* The object should throw TypeError */
+  return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+} /* ecma_builtin_type_error_thrower_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in [[ThrowTypeError]] object
+ *
+ * See also:
+ *          ECMA-262 v5, 13.2.3
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_type_error_thrower_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                                    ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  /* The object is not a constructor */
+  return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
+} /* ecma_builtin_type_error_thrower_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtin-type-error-thrower.inc.h

@@ -0,0 +1,48 @@
+/* Copyright 2014 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.
+ */
+
+/*
+ * [[ThrowTypeError]] description
+ *
+ * See also: ECMA-262 v5, 13.2.3
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_TYPE_ERROR_THROWER)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              0,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-typeerror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-typeerror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID type_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-typeerror-prototype.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * TypeError.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_TYPE_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.7.8
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_TYPE_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.9
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_TYPE_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.10
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-typeerror.inc.h"
+#define BUILTIN_UNDERSCORED_ID type_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup typeerror ECMA TypeError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in TypeError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_type_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                       ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_TYPE,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_TYPE);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_type_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in TypeError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_type_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                            ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_type_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_type_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-typeerror.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * TypeError built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_TYPE_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_TYPE_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtin-urierror-prototype.cpp

@@ -0,0 +1,37 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-string-object.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-urierror-prototype.inc.h"
+#define BUILTIN_UNDERSCORED_ID uri_error_prototype
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-urierror-prototype.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * UriError.prototype built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_URI_ERROR_PROTOTYPE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.7.8
+OBJECT_VALUE (ECMA_MAGIC_STRING_CONSTRUCTOR,
+              ecma_builtin_get (ECMA_BUILTIN_ID_URI_ERROR),
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.9
+STRING_VALUE (ECMA_MAGIC_STRING_NAME,
+              ECMA_MAGIC_STRING_URI_ERROR_UL,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+// 15.11.7.10
+STRING_VALUE (ECMA_MAGIC_STRING_MESSAGE,
+              ECMA_MAGIC_STRING__EMPTY,
+              ECMA_PROPERTY_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

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

@@ -0,0 +1,101 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-conversion.h"
+#include "ecma-exceptions.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "ecma-try-catch-macro.h"
+#include "jrt.h"
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+#define BUILTIN_INC_HEADER_NAME "ecma-builtin-urierror.inc.h"
+#define BUILTIN_UNDERSCORED_ID uri_error
+#include "ecma-builtin-internal-routines-template.inc.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ *
+ * \addtogroup urierror ECMA UriError object built-in
+ * @{
+ */
+
+/**
+ * Handle calling [[Call]] of built-in UriError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_uri_error_dispatch_call (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                      ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (arguments_list_len != 0
+      && !ecma_is_value_undefined (arguments_list_p [0]))
+  {
+    ecma_completion_value_t ret_value;
+
+    ECMA_TRY_CATCH (msg_str_value,
+                    ecma_op_to_string (arguments_list_p[0]),
+                    ret_value);
+
+    ecma_string_t *message_string_p = ecma_get_string_from_value (msg_str_value);
+    ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_URI,
+                                                                              message_string_p);
+    ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+
+    ECMA_FINALIZE (msg_str_value);
+
+    return ret_value;
+  }
+  else
+  {
+    ecma_object_t *new_error_object_p = ecma_new_standard_error (ECMA_ERROR_URI);
+
+    return ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));
+  }
+} /* ecma_builtin_uri_error_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in UriError object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_uri_error_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
+                                           ecma_length_t arguments_list_len) /**< number of arguments */
+{
+  return ecma_builtin_uri_error_dispatch_call (arguments_list_p, arguments_list_len);
+} /* ecma_builtin_uri_error_dispatch_construct */
+
+/**
+ * @}
+ * @}
+ * @}
+ */
+
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */

jerry-core/ecma/builtin-objects/ecma-builtin-urierror.inc.h

@@ -0,0 +1,65 @@
+/* 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.
+ */
+
+/*
+ * UriError built-in description
+ */
+
+#ifndef OBJECT_ID
+# define OBJECT_ID(builtin_object_id)
+#endif /* !OBJECT_ID */
+
+#ifndef NUMBER_VALUE
+# define NUMBER_VALUE(name, number_value, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !NUMBER_VALUE */
+
+#ifndef STRING_VALUE
+# define STRING_VALUE(name, magic_string_id, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !STRING_VALUE */
+
+#ifndef OBJECT_VALUE
+# define OBJECT_VALUE(name, obj_getter, prop_writable, prop_enumerable, prop_configurable)
+#endif /* !OBJECT_VALUE */
+
+/* Object identifier */
+OBJECT_ID (ECMA_BUILTIN_ID_URI_ERROR)
+
+/* Number properties:
+ *  (property name, number value, writable, enumerable, configurable) */
+
+// 15.11.3
+NUMBER_VALUE (ECMA_MAGIC_STRING_LENGTH,
+              1,
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+/* Object properties:
+ *  (property name, object pointer getter) */
+
+// 15.11.3.1
+OBJECT_VALUE (ECMA_MAGIC_STRING_PROTOTYPE,
+              ecma_builtin_get (ECMA_BUILTIN_ID_URI_ERROR_PROTOTYPE),
+              ECMA_PROPERTY_NOT_WRITABLE,
+              ECMA_PROPERTY_NOT_ENUMERABLE,
+              ECMA_PROPERTY_NOT_CONFIGURABLE)
+
+#undef OBJECT_ID
+#undef SIMPLE_VALUE
+#undef NUMBER_VALUE
+#undef STRING_VALUE
+#undef OBJECT_VALUE
+#undef CP_UNIMPLEMENTED_VALUE
+#undef ROUTINE

jerry-core/ecma/builtin-objects/ecma-builtins-internal.h

@@ -0,0 +1,98 @@
+/* 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.
+ */
+
+#ifndef ECMA_BUILTINS_INTERNAL_H
+#define ECMA_BUILTINS_INTERNAL_H
+
+#ifndef ECMA_BUILTINS_INTERNAL
+# error "!ECMA_BUILTINS_INTERNAL"
+#endif /* !ECMA_BUILTINS_INTERNAL */
+
+#include "ecma-builtins.h"
+#include "ecma-globals.h"
+
+/**
+ * Position of built-in object's id field in [[Built-in routine ID]] internal property
+ */
+#define ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_POS   (0)
+
+/**
+ * Width of built-in object's id field in [[Built-in routine ID]] internal property
+ */
+#define ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_WIDTH (16)
+
+/**
+ * Position of built-in routine's id field in [[Built-in routine ID]] internal property
+ */
+#define ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_ROUTINE_ID_POS \
+  (ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_POS + \
+   ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_WIDTH)
+
+/**
+ * Width of built-in routine's id field in [[Built-in routine ID]] internal property
+ */
+#define ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_ROUTINE_ID_WIDTH (16)
+
+/* ecma-builtins.c */
+extern ecma_object_t*
+ecma_builtin_make_function_object_for_routine (ecma_builtin_id_t builtin_id,
+                                               ecma_magic_string_id_t routine_id,
+                                               ecma_number_t length_prop_num_value);
+extern int32_t
+ecma_builtin_bin_search_for_magic_string_id_in_array (const ecma_magic_string_id_t ids[],
+                                                      ecma_length_t array_length,
+                                                      ecma_magic_string_id_t key);
+
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+extern ecma_completion_value_t \
+ecma_builtin_ ## lowercase_name ## _dispatch_call (const ecma_value_t *arguments_list_p, \
+                                                   ecma_length_t arguments_list_len); \
+extern ecma_completion_value_t \
+ecma_builtin_ ## lowercase_name ## _dispatch_construct (const ecma_value_t *arguments_list_p, \
+                                                        ecma_length_t arguments_list_len); \
+extern ecma_completion_value_t \
+ecma_builtin_ ## lowercase_name ## _dispatch_routine (ecma_magic_string_id_t builtin_routine_id, \
+                                                      const ecma_value_t& this_arg_value, \
+                                                      const ecma_value_t arguments_list [], \
+                                                      ecma_length_t arguments_number); \
+extern ecma_property_t* \
+ecma_builtin_ ## lowercase_name ## _try_to_instantiate_property (ecma_object_t *obj_p, \
+                                                                 ecma_string_t *prop_name_p); \
+extern void \
+ecma_builtin_ ## lowercase_name ## _sort_property_names (void);
+#include "ecma-builtins.inc.h"
+
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE
+# define ECMA_BUILTIN_CP_UNIMPLEMENTED(...) \
+  JERRY_UNIMPLEMENTED_REF_UNUSED_VARS ("Built-in is not implemented.", __VA_ARGS__)
+#else /* !CONFIG_ECMA_COMPACT_PROFILE */
+# define ECMA_BUILTIN_CP_UNIMPLEMENTED(...) \
+{ \
+  if (false) \
+  { \
+    jerry_ref_unused_variables (0, __VA_ARGS__); \
+  } \
+  ecma_object_t *cp_error_p = ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR); \
+  return ecma_make_throw_obj_completion_value (cp_error_p); \
+}
+#endif /* CONFIG_ECMA_COMPACT_PROFILE */
+
+#endif /* !ECMA_BUILTINS_INTERNAL_H */

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

@@ -0,0 +1,610 @@
+/* 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.
+ */
+
+#include "ecma-alloc.h"
+#include "ecma-builtins.h"
+#include "ecma-gc.h"
+#include "ecma-globals.h"
+#include "ecma-helpers.h"
+#include "ecma-objects.h"
+#include "jrt-bit-fields.h"
+
+#define ECMA_BUILTINS_INTERNAL
+#include "ecma-builtins-internal.h"
+
+/** \addtogroup ecma ECMA
+ * @{
+ *
+ * \addtogroup ecmabuiltins
+ * @{
+ */
+
+static ecma_completion_value_t
+ecma_builtin_dispatch_routine (ecma_builtin_id_t builtin_object_id,
+                               ecma_magic_string_id_t builtin_routine_id,
+                               const ecma_value_t& this_arg_value,
+                               const ecma_value_t arguments_list [],
+                               ecma_length_t arguments_number);
+static void ecma_instantiate_builtin (ecma_builtin_id_t id);
+
+/**
+ * Pointer to instances of built-in objects
+ */
+static ecma_object_t* ecma_builtin_objects [ECMA_BUILTIN_ID__COUNT];
+
+/**
+ * Check if passed object is the instance of specified built-in.
+ */
+bool
+ecma_builtin_is (ecma_object_t *obj_p, /**< pointer to an object */
+                 ecma_builtin_id_t builtin_id) /**< id of built-in to check on */
+{
+  JERRY_ASSERT (obj_p != NULL && !ecma_is_lexical_environment (obj_p));
+  JERRY_ASSERT (builtin_id < ECMA_BUILTIN_ID__COUNT);
+
+  if (unlikely (ecma_builtin_objects [builtin_id] == NULL))
+  {
+    ecma_instantiate_builtin (builtin_id);
+  }
+
+  return (obj_p == ecma_builtin_objects [builtin_id]);
+} /* ecma_builtin_is */
+
+/**
+ * Get reference to specified built-in object
+ *
+ * @return pointer to the object's instance
+ */
+ecma_object_t*
+ecma_builtin_get (ecma_builtin_id_t builtin_id) /**< id of built-in to check on */
+{
+  JERRY_ASSERT (builtin_id < ECMA_BUILTIN_ID__COUNT);
+
+  if (unlikely (ecma_builtin_objects [builtin_id] == NULL))
+  {
+    ecma_instantiate_builtin (builtin_id);
+  }
+
+  ecma_ref_object (ecma_builtin_objects [builtin_id]);
+
+  return ecma_builtin_objects [builtin_id];
+} /* ecma_builtin_get */
+
+/**
+ * Initialize specified built-in object.
+ *
+ * Warning:
+ *         the routine should be called only from ecma_init_builtins
+ *
+ * @return pointer to the object
+ */
+static ecma_object_t*
+ecma_builtin_init_object (ecma_builtin_id_t obj_builtin_id, /**< built-in ID */
+                          ecma_object_t* prototype_obj_p, /**< prototype object */
+                          ecma_object_type_t obj_type, /**< object's type */
+                          ecma_magic_string_id_t obj_class, /**< object's class */
+                          bool is_extensible) /**< value of object's [[Extensible]] property */
+{
+  ecma_object_t *object_obj_p = ecma_create_object (prototype_obj_p, is_extensible, obj_type);
+
+  ecma_property_t *class_prop_p = ecma_create_internal_property (object_obj_p,
+                                                                 ECMA_INTERNAL_PROPERTY_CLASS);
+  class_prop_p->u.internal_property.value = obj_class;
+
+  ecma_property_t *built_in_id_prop_p = ecma_create_internal_property (object_obj_p,
+                                                                       ECMA_INTERNAL_PROPERTY_BUILT_IN_ID);
+  built_in_id_prop_p->u.internal_property.value = obj_builtin_id;
+
+  ecma_set_object_is_builtin (object_obj_p, true);
+
+  /** Initializing [[PrimitiveValue]] properties of built-in prototype objects */
+  switch (obj_builtin_id)
+  {
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN
+    case ECMA_BUILTIN_ID_STRING_PROTOTYPE:
+    {
+      ecma_string_t *prim_prop_str_value_p = ecma_get_magic_string (ECMA_MAGIC_STRING__EMPTY);
+
+      ecma_property_t *prim_value_prop_p;
+      prim_value_prop_p = ecma_create_internal_property (object_obj_p,
+                                                         ECMA_INTERNAL_PROPERTY_PRIMITIVE_STRING_VALUE);
+      ECMA_SET_POINTER (prim_value_prop_p->u.internal_property.value, prim_prop_str_value_p);
+      break;
+    }
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
+    case ECMA_BUILTIN_ID_NUMBER_PROTOTYPE:
+    {
+      ecma_number_t *prim_prop_num_value_p = ecma_alloc_number ();
+      *prim_prop_num_value_p = ECMA_NUMBER_ZERO;
+
+      ecma_property_t *prim_value_prop_p;
+      prim_value_prop_p = ecma_create_internal_property (object_obj_p,
+                                                         ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
+      ECMA_SET_POINTER (prim_value_prop_p->u.internal_property.value, prim_prop_num_value_p);
+      break;
+    }
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
+    case ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE:
+    {
+      ecma_property_t *prim_value_prop_p;
+      prim_value_prop_p = ecma_create_internal_property (object_obj_p,
+                                                         ECMA_INTERNAL_PROPERTY_PRIMITIVE_BOOLEAN_VALUE);
+      prim_value_prop_p->u.internal_property.value = ECMA_SIMPLE_VALUE_FALSE;
+      break;
+    }
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */
+
+    default:
+    {
+      break;
+    }
+  }
+
+  return object_obj_p;
+} /* ecma_builtin_init_object */
+
+/**
+ * Initialize ECMA built-ins components
+ */
+void
+ecma_init_builtins (void)
+{
+  for (ecma_builtin_id_t id = (ecma_builtin_id_t) 0;
+       id < ECMA_BUILTIN_ID__COUNT;
+       id = (ecma_builtin_id_t) (id + 1))
+  {
+    ecma_builtin_objects [id] = NULL;
+  }
+} /* ecma_init_builtins */
+
+/**
+ * Instantiate specified ECMA built-in object
+ */
+static void
+ecma_instantiate_builtin (ecma_builtin_id_t id) /**< built-in id */
+{
+  switch (id)
+  {
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+    case builtin_id: \
+    { \
+      JERRY_ASSERT (ecma_builtin_objects [builtin_id] == NULL); \
+      ecma_builtin_ ## lowercase_name ## _sort_property_names (); \
+      \
+      ecma_object_t *prototype_obj_p; \
+      if (object_prototype_builtin_id == ECMA_BUILTIN_ID__COUNT) \
+      { \
+        prototype_obj_p = NULL; \
+      } \
+      else \
+      { \
+        if (ecma_builtin_objects [object_prototype_builtin_id] == NULL) \
+        { \
+          ecma_instantiate_builtin (object_prototype_builtin_id); \
+        } \
+        prototype_obj_p = ecma_builtin_objects [object_prototype_builtin_id]; \
+        JERRY_ASSERT (prototype_obj_p != NULL); \
+      } \
+      \
+      ecma_object_t *builtin_obj_p =  ecma_builtin_init_object (builtin_id, \
+                                                                prototype_obj_p, \
+                                                                object_type, \
+                                                                object_class, \
+                                                                is_extensible); \
+      ecma_builtin_objects [builtin_id] = builtin_obj_p; \
+      \
+      break; \
+    }
+#include "ecma-builtins.inc.h"
+
+    default:
+    {
+      JERRY_ASSERT (id < ECMA_BUILTIN_ID__COUNT);
+
+      JERRY_UNIMPLEMENTED ("The built-in is not implemented.");
+    }
+  }
+} /* ecma_instantiate_builtin */
+
+/**
+ * Finalize ECMA built-in objects
+ */
+void
+ecma_finalize_builtins (void)
+{
+  for (ecma_builtin_id_t id = (ecma_builtin_id_t) 0;
+       id < ECMA_BUILTIN_ID__COUNT;
+       id = (ecma_builtin_id_t) (id + 1))
+  {
+    if (ecma_builtin_objects [id] != NULL)
+    {
+      ecma_deref_object (ecma_builtin_objects [id]);
+
+      ecma_builtin_objects [id] = NULL;
+    }
+  }
+} /* ecma_finalize_builtins */
+
+/**
+ * If the property's name is one of built-in properties of the object
+ * that is not instantiated yet, instantiate the property and
+ * return pointer to the instantiated property.
+ *
+ * @return pointer property, if one was instantiated,
+ *         NULL - otherwise.
+ */
+ecma_property_t*
+ecma_builtin_try_to_instantiate_property (ecma_object_t *object_p, /**< object */
+                                          ecma_string_t *string_p) /**< property's name */
+{
+  JERRY_ASSERT (ecma_get_object_is_builtin (object_p));
+
+  ecma_property_t *built_in_id_prop_p = ecma_get_internal_property (object_p,
+                                                                    ECMA_INTERNAL_PROPERTY_BUILT_IN_ID);
+  ecma_builtin_id_t builtin_id = (ecma_builtin_id_t) built_in_id_prop_p->u.internal_property.value;
+
+  JERRY_ASSERT (ecma_builtin_is (object_p, builtin_id));
+
+  switch (builtin_id)
+  {
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+    case builtin_id: \
+    { \
+      return ecma_builtin_ ## lowercase_name ## _try_to_instantiate_property (object_p, \
+                                                                              string_p); \
+    }
+#include "ecma-builtins.inc.h"
+
+    case ECMA_BUILTIN_ID__COUNT:
+    {
+      JERRY_UNREACHABLE ();
+    }
+
+    default:
+    {
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+      JERRY_UNREACHABLE ();
+#else /* CONFIG_ECMA_COMPACT_PROFILE */
+      JERRY_UNIMPLEMENTED ("The built-in is not implemented.");
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE */
+    }
+  }
+
+  JERRY_UNREACHABLE ();
+} /* ecma_builtin_try_to_instantiate_property */
+
+/**
+ * Construct a Function object for specified built-in routine
+ *
+ * See also: ECMA-262 v5, 15
+ *
+ * @return pointer to constructed Function object
+ */
+ecma_object_t*
+ecma_builtin_make_function_object_for_routine (ecma_builtin_id_t builtin_id, /**< identifier of built-in object
+                                                                                  that initially contains property
+                                                                                  with the routine */
+                                               ecma_magic_string_id_t routine_id, /**< name of the built-in
+                                                                                       object's routine property */
+                                               ecma_number_t length_prop_num_value) /**< ecma-number - value
+                                                                                         of 'length' property
+                                                                                         of function object to create */
+{
+  ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE);
+
+  ecma_object_t *func_obj_p = ecma_create_object (prototype_obj_p, true, ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION);
+
+  ecma_deref_object (prototype_obj_p);
+
+  ecma_set_object_is_builtin (func_obj_p, true);
+
+  uint64_t packed_value = jrt_set_bit_field_value (0,
+                                                   builtin_id,
+                                                   ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_POS,
+                                                   ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_WIDTH);
+  packed_value = jrt_set_bit_field_value (packed_value,
+                                          routine_id,
+                                          ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_ROUTINE_ID_POS,
+                                          ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_ROUTINE_ID_WIDTH);
+  ecma_property_t *routine_id_prop_p = ecma_create_internal_property (func_obj_p,
+                                                                      ECMA_INTERNAL_PROPERTY_BUILT_IN_ROUTINE_ID);
+
+  JERRY_ASSERT ((uint32_t) packed_value == packed_value);
+  routine_id_prop_p->u.internal_property.value = (uint32_t) packed_value;
+
+  ecma_string_t* magic_string_length_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
+  ecma_property_t *len_prop_p = ecma_create_named_data_property (func_obj_p,
+                                                                 magic_string_length_p,
+                                                                 false, false, false);
+
+  ecma_deref_ecma_string (magic_string_length_p);
+
+  ecma_number_t* len_p = ecma_alloc_number ();
+  *len_p = length_prop_num_value;
+
+  ecma_set_named_data_property_value (len_prop_p, ecma_make_number_value (len_p));
+
+  return func_obj_p;
+} /* ecma_builtin_make_function_object_for_routine */
+
+/**
+ * Handle calling [[Call]] of built-in object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_dispatch_call (ecma_object_t *obj_p, /**< built-in object */
+                            const ecma_value_t& this_arg_value, /**< 'this' argument value */
+                            const ecma_value_t *arguments_list_p, /**< arguments list */
+                            ecma_length_t arguments_list_len) /**< length of the arguments list */
+{
+  JERRY_ASSERT (ecma_get_object_is_builtin (obj_p));
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  if (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION)
+  {
+    ecma_property_t *id_prop_p = ecma_get_internal_property (obj_p,
+                                                             ECMA_INTERNAL_PROPERTY_BUILT_IN_ROUTINE_ID);
+    uint64_t packed_built_in_and_routine_id = id_prop_p->u.internal_property.value;
+
+    uint64_t built_in_id_field = jrt_extract_bit_field (packed_built_in_and_routine_id,
+                                                        ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_POS,
+                                                        ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_OBJECT_ID_WIDTH);
+    JERRY_ASSERT (built_in_id_field < ECMA_BUILTIN_ID__COUNT);
+
+    uint64_t routine_id_field = jrt_extract_bit_field (packed_built_in_and_routine_id,
+                                                       ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_ROUTINE_ID_POS,
+                                                       ECMA_BUILTIN_ROUTINE_ID_BUILT_IN_ROUTINE_ID_WIDTH);
+    JERRY_ASSERT (routine_id_field < ECMA_MAGIC_STRING__COUNT);
+
+    ecma_builtin_id_t built_in_id = (ecma_builtin_id_t) built_in_id_field;
+    ecma_magic_string_id_t routine_id = (ecma_magic_string_id_t) routine_id_field;
+
+    return ecma_builtin_dispatch_routine (built_in_id,
+                                          routine_id,
+                                          this_arg_value,
+                                          arguments_list_p,
+                                          arguments_list_len);
+  }
+  else
+  {
+    JERRY_ASSERT (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_FUNCTION);
+
+    ecma_property_t *built_in_id_prop_p = ecma_get_internal_property (obj_p,
+                                                                      ECMA_INTERNAL_PROPERTY_BUILT_IN_ID);
+    ecma_builtin_id_t builtin_id = (ecma_builtin_id_t) built_in_id_prop_p->u.internal_property.value;
+
+    JERRY_ASSERT (ecma_builtin_is (obj_p, builtin_id));
+
+    switch (builtin_id)
+    {
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+      case builtin_id: \
+      { \
+        if (object_type == ECMA_OBJECT_TYPE_FUNCTION) \
+        { \
+          return ecma_builtin_ ## lowercase_name ## _dispatch_call (arguments_list_p, \
+                                                                    arguments_list_len); \
+        } \
+        else \
+        { \
+          JERRY_UNREACHABLE (); \
+        } \
+      }
+#include "ecma-builtins.inc.h"
+
+      case ECMA_BUILTIN_ID__COUNT:
+      {
+        JERRY_UNREACHABLE ();
+      }
+
+      default:
+      {
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+        JERRY_UNREACHABLE ();
+#else /* CONFIG_ECMA_COMPACT_PROFILE */
+        JERRY_UNIMPLEMENTED ("The built-in is not implemented.");
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE */
+      }
+    }
+  }
+
+  JERRY_UNREACHABLE ();
+} /* ecma_builtin_dispatch_call */
+
+/**
+ * Handle calling [[Construct]] of built-in object
+ *
+ * @return completion-value
+ */
+ecma_completion_value_t
+ecma_builtin_dispatch_construct (ecma_object_t *obj_p, /**< built-in object */
+                                 const ecma_value_t *arguments_list_p, /**< arguments list */
+                                 ecma_length_t arguments_list_len) /**< length of the arguments list */
+{
+  JERRY_ASSERT (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_FUNCTION);
+
+  JERRY_ASSERT (ecma_get_object_is_builtin (obj_p));
+  JERRY_ASSERT (arguments_list_len == 0 || arguments_list_p != NULL);
+
+  ecma_property_t *built_in_id_prop_p = ecma_get_internal_property (obj_p,
+                                                                    ECMA_INTERNAL_PROPERTY_BUILT_IN_ID);
+  ecma_builtin_id_t builtin_id = (ecma_builtin_id_t) built_in_id_prop_p->u.internal_property.value;
+
+  JERRY_ASSERT (ecma_builtin_is (obj_p, builtin_id));
+
+  switch (builtin_id)
+  {
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+    case builtin_id: \
+      { \
+        if (object_type == ECMA_OBJECT_TYPE_FUNCTION) \
+        { \
+          return ecma_builtin_ ## lowercase_name ## _dispatch_construct (arguments_list_p, \
+                                                                         arguments_list_len); \
+        } \
+        else \
+        { \
+          JERRY_UNREACHABLE (); \
+        } \
+      }
+#include "ecma-builtins.inc.h"
+
+    case ECMA_BUILTIN_ID__COUNT:
+    {
+      JERRY_UNREACHABLE ();
+    }
+
+    default:
+    {
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+      JERRY_UNREACHABLE ();
+#else /* CONFIG_ECMA_COMPACT_PROFILE */
+      JERRY_UNIMPLEMENTED ("The built-in is not implemented.");
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE */
+    }
+  }
+
+  JERRY_UNREACHABLE ();
+} /* ecma_builtin_dispatch_construct */
+
+/**
+ * Dispatcher of built-in routines
+ *
+ * @return completion-value
+ *         Returned value must be freed with ecma_free_completion_value.
+ */
+static ecma_completion_value_t
+ecma_builtin_dispatch_routine (ecma_builtin_id_t builtin_object_id, /**< built-in object' identifier */
+                               ecma_magic_string_id_t builtin_routine_id, /**< name of the built-in object's
+                                                                               routine property */
+                               const ecma_value_t& this_arg_value, /**< 'this' argument value */
+                               const ecma_value_t arguments_list [], /**< list of arguments passed to routine */
+                               ecma_length_t arguments_number) /**< length of arguments' list */
+{
+  switch (builtin_object_id)
+  {
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+    case builtin_id: \
+      { \
+        return ecma_builtin_ ## lowercase_name ## _dispatch_routine (builtin_routine_id, \
+                                                                     this_arg_value, \
+                                                                     arguments_list, \
+                                                                     arguments_number); \
+      }
+#include "ecma-builtins.inc.h"
+
+    case ECMA_BUILTIN_ID__COUNT:
+    {
+      JERRY_UNREACHABLE ();
+    }
+
+    default:
+    {
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+      JERRY_UNREACHABLE ();
+#else /* CONFIG_ECMA_COMPACT_PROFILE */
+      JERRY_UNIMPLEMENTED ("The built-in is not implemented.");
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE */
+    }
+  }
+
+  JERRY_UNREACHABLE ();
+} /* ecma_builtin_dispatch_routine */
+
+/**
+ * Binary search for magic string identifier in array.
+ *
+ * Warning:
+ *         array should be sorted in ascending order
+ *
+ * @return index of identifier, if it is contained in array,
+ *         -1 - otherwise.
+ */
+int32_t
+ecma_builtin_bin_search_for_magic_string_id_in_array (const ecma_magic_string_id_t ids[], /**< array to search in */
+                                                      ecma_length_t array_length, /**< number of elements
+                                                                                       in the array */
+                                                      ecma_magic_string_id_t key) /**< value to search for */
+{
+#ifndef JERRY_NDEBUG
+  /* For binary search the values should be sorted */
+  for (ecma_length_t id_index = 1;
+       id_index < array_length;
+       id_index++)
+  {
+    JERRY_ASSERT (ids [id_index - 1] < ids [id_index]);
+  }
+#endif /* !JERRY_NDEBUG */
+
+  int32_t min = 0;
+  int32_t max = array_length - 1;
+
+  while (min <= max)
+  {
+    int32_t mid = (min + max) / 2;
+
+    if (ids[mid] == key)
+    {
+      return mid;
+    }
+    else if (ids[mid] > key)
+    {
+      max = mid - 1;
+    }
+    else
+    {
+      JERRY_ASSERT (ids[mid] < key);
+
+      min = mid + 1;
+    }
+  }
+
+  return -1;
+} /* ecma_builtin_bin_search_for_magic_string_id_in_array */
+
+/**
+ * @}
+ * @}
+ */

jerry-core/ecma/builtin-objects/ecma-builtins.h

@@ -0,0 +1,58 @@
+/* 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.
+ */
+
+#ifndef ECMA_BUILTINS_H
+#define ECMA_BUILTINS_H
+
+#include "ecma-globals.h"
+
+/**
+ * A built-in object's identifier
+ */
+typedef enum
+{
+#define BUILTIN(builtin_id, \
+                object_type, \
+                object_class, \
+                object_prototype_builtin_id, \
+                is_extensible, \
+                lowercase_name) \
+  builtin_id,
+#include "ecma-builtins.inc.h"
+  ECMA_BUILTIN_ID__COUNT /**< number of built-in objects */
+} ecma_builtin_id_t;
+
+/* ecma-builtins.c */
+extern void ecma_init_builtins (void);
+extern void ecma_finalize_builtins (void);
+
+extern ecma_completion_value_t
+ecma_builtin_dispatch_call (ecma_object_t *obj_p,
+                            const ecma_value_t& this_arg,
+                            const ecma_value_t *arguments_list_p,
+                            ecma_length_t arguments_list_len);
+extern ecma_completion_value_t
+ecma_builtin_dispatch_construct (ecma_object_t *obj_p,
+                                 const ecma_value_t *arguments_list_p,
+                                 ecma_length_t arguments_list_len);
+extern ecma_property_t*
+ecma_builtin_try_to_instantiate_property (ecma_object_t *object_p,
+                                          ecma_string_t *string_p);
+extern bool
+ecma_builtin_is (ecma_object_t *obj_p,
+                 ecma_builtin_id_t builtin_id);
+extern ecma_object_t*
+ecma_builtin_get (ecma_builtin_id_t builtin_id);
+#endif /* !ECMA_BUILTINS_H */

jerry-core/ecma/builtin-objects/ecma-builtins.inc.h

@@ -0,0 +1,273 @@
+/* Copyright 2014 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.
+ */
+
+/* Description of built-in objects
+   in format (ECMA_BUILTIN_ID_id, object_type, class_magic_string_id, prototype_id, is_extensible, underscored_id) */
+
+/* The Object.prototype object (15.2.4) */
+BUILTIN (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_OBJECT_UL,
+         ECMA_BUILTIN_ID__COUNT /* no prototype */,
+         true,
+         object_prototype)
+
+/* The Object object (15.2.1) */
+BUILTIN (ECMA_BUILTIN_ID_OBJECT,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_OBJECT_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         object)
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN
+/* The Array.prototype object (15.4.4) */
+BUILTIN (ECMA_BUILTIN_ID_ARRAY_PROTOTYPE,
+         ECMA_OBJECT_TYPE_ARRAY,
+         ECMA_MAGIC_STRING_ARRAY_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         array_prototype)
+
+/* The Array object (15.4.1) */
+BUILTIN (ECMA_BUILTIN_ID_ARRAY,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ARRAY_UL,
+         ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         true,
+         array)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN*/
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN
+/* The String.prototype object (15.5.4) */
+BUILTIN (ECMA_BUILTIN_ID_STRING_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_STRING_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         string_prototype)
+
+/* The String object (15.5.1) */
+BUILTIN (ECMA_BUILTIN_ID_STRING,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_STRING_UL,
+         ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         true,
+         string)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
+/* The Boolean.prototype object (15.6.4) */
+BUILTIN (ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_BOOLEAN_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         boolean_prototype)
+
+/* The Boolean object (15.6.1) */
+BUILTIN (ECMA_BUILTIN_ID_BOOLEAN,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_BOOLEAN_UL,
+         ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         true,
+         boolean)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
+/* The Number.prototype object (15.7.4) */
+BUILTIN (ECMA_BUILTIN_ID_NUMBER_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_NUMBER_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         number_prototype)
+
+/* The Number object (15.7.1) */
+BUILTIN (ECMA_BUILTIN_ID_NUMBER,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_NUMBER_UL,
+         ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         true,
+         number)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */
+
+/* The Function.prototype object (15.3.4) */
+BUILTIN (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_FUNCTION_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         function_prototype)
+
+/* The Function object (15.3.1) */
+BUILTIN (ECMA_BUILTIN_ID_FUNCTION,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_FUNCTION_UL,
+         ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         true,
+         function)
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_MATH_BUILTIN
+/* The Math object (15.8) */
+BUILTIN (ECMA_BUILTIN_ID_MATH,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_MATH_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         math)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_MATH_BUILTIN */
+
+#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
+/* The Error.prototype object (15.11.4) */
+BUILTIN (ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         true,
+         error_prototype)
+
+/* The Error object (15.11.1) */
+BUILTIN (ECMA_BUILTIN_ID_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         error)
+
+/* The EvalError.prototype object (15.11.6.1) */
+BUILTIN (ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         eval_error_prototype)
+
+/* The EvalError object (15.11.6.1) */
+BUILTIN (ECMA_BUILTIN_ID_EVAL_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE,
+         true,
+         eval_error)
+
+/* The RangeError.prototype object (15.11.6.2) */
+BUILTIN (ECMA_BUILTIN_ID_RANGE_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         range_error_prototype)
+
+/* The RangeError object (15.11.6.2) */
+BUILTIN (ECMA_BUILTIN_ID_RANGE_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_RANGE_ERROR_PROTOTYPE,
+         true,
+         range_error)
+
+/* The ReferenceError.prototype object (15.11.6.3) */
+BUILTIN (ECMA_BUILTIN_ID_REFERENCE_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         reference_error_prototype)
+
+/* The ReferenceError object (15.11.6.3) */
+BUILTIN (ECMA_BUILTIN_ID_REFERENCE_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_REFERENCE_ERROR_PROTOTYPE,
+         true,
+         reference_error)
+
+/* The SyntaxError.prototype object (15.11.6.4) */
+BUILTIN (ECMA_BUILTIN_ID_SYNTAX_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         syntax_error_prototype)
+
+/* The SyntaxError object (15.11.6.4) */
+BUILTIN (ECMA_BUILTIN_ID_SYNTAX_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_SYNTAX_ERROR_PROTOTYPE,
+         true,
+         syntax_error)
+
+/* The TypeError.prototype object (15.11.6.5) */
+BUILTIN (ECMA_BUILTIN_ID_TYPE_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         type_error_prototype)
+
+/* The TypeError object (15.11.6.5) */
+BUILTIN (ECMA_BUILTIN_ID_TYPE_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_TYPE_ERROR_PROTOTYPE,
+         true,
+         type_error)
+
+/* The URIError.prototype object (15.11.6.6) */
+BUILTIN (ECMA_BUILTIN_ID_URI_ERROR_PROTOTYPE,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_ERROR_PROTOTYPE,
+         true,
+         uri_error_prototype)
+
+/* The URIError object (15.11.6.6) */
+BUILTIN (ECMA_BUILTIN_ID_URI_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_ERROR_UL,
+         ECMA_BUILTIN_ID_URI_ERROR_PROTOTYPE,
+         true,
+         uri_error)
+#endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */
+
+/**< The [[ThrowTypeError]] object (13.2.3) */
+BUILTIN (ECMA_BUILTIN_ID_TYPE_ERROR_THROWER,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_FUNCTION_UL,
+         ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE,
+         false,
+         type_error_thrower)
+
+#ifdef CONFIG_ECMA_COMPACT_PROFILE
+/* The CompactProfileError object defined in the Compact Profile */
+BUILTIN (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR,
+         ECMA_OBJECT_TYPE_FUNCTION,
+         ECMA_MAGIC_STRING_COMPACT_PROFILE_ERROR_UL,
+         ECMA_BUILTIN_ID_OBJECT_PROTOTYPE,
+         false,
+         compact_profile_error)
+#endif /* CONFIG_ECMA_COMPACT_PROFILE */
+
+/* The Global object (15.1) */
+BUILTIN (ECMA_BUILTIN_ID_GLOBAL,
+         ECMA_OBJECT_TYPE_GENERAL,
+         ECMA_MAGIC_STRING_OBJECT_UL,
+         ECMA_BUILTIN_ID__COUNT /* no prototype */,
+         true,
+         global)
+
+#undef BUILTIN