Rework usages/naming of configuration macros [part 2] (#2903)

There are quite a few configuration macros in the project.
As discussed in the #2520 issue there are a few awkward constructs.

Main changes:

* The following macros are now 0/1 switches:
** Renamed CONFIG_ECMA_LCACHE_DISABLE to JERRY_LCACHE.
** Renamed CONFIG_ECMA_PROPERTY_HASHMAP_DISABLE to JERRY_PROPERTY_HASHMAP.
** Renamed CONFIG_DISABLE_UNICODE_CASE_CONVERSION to JERRY_UNICODE_CASE_CONVERSION.
** Renamed ENABLE_REGEXP_STRICT_MODE to JERRY_REGEXP_STRICT_MODE.
** Renamed JERRY_DISABLE_JS_PARSER to JERRY_PARSER.
** Renamed JERRY_ENABLE_ERROR_MESSAGES to JERRY_ERROR_MESSAGES.
** Renamed JERRY_ENABLE_EXTERNAL_CONTEXT to JERRY_EXTERNAL_CONTEXT.
** Renamed JERRY_ENABLE_LINE_INFO to JERRY_LINE_INFO.
** Renamed JERRY_ENABLE_LOGGING to JERRY_LOGGING.
** Renamed JERRY_ENABLE_SNAPSHOT_EXEC to JERRY_SNAPSHOT_EXEC.
** Renamed JERRY_ENABLE_SNAPSHOT_SAVE to JERRY_SNAPSHOT_SAVE.
** Renamed JERRY_SYSTEM_ALLOCATOR to JERRY_SYSTEM_ALLOCATOR.
** Renamed JERRY_VM_EXEC_STOP to JERRY_VM_EXEC_STOP.
** Renamed JMEM_GC_BEFORE_EACH_ALLOC to JERRY_MEM_GC_BEFORE_EACH_ALLOC.
** Renamed JMEM_STATS to JERRY_MEM_STATS.
** Renamed PARSER_DUMP_BYTE_CODE to JERRY_PARSER_DUMP_BYTE_CODE.
** Renamed REGEXP_DUMP_BYTE_CODE to JERRY_REGEXP_DUMP_BYTE_CODE.
* Recursion check changes:
** Renamed REGEXP_RECURSION_LIMIT to JERRY_REGEXP_RECURSION_LIMIT.
** Renamed VM_RECURSION_LIMIT to JERRY_VM_RECURSION_LIMIT.
* Attribute macro changes:
** Renamed JERRY_CONST_DATA to JERRY_ATTR_CONST_DATA.
** Renamed JERRY_HEAP_SECTION_ATTR to JERRY_ATTR_GLOBAL_HEAP.
  Now the macro can specify any attribute for the global heap object.
* Other macro changes:
** Renamed CONFIG_MEM_HEAP_AREA_SIZE to JERRY_GLOBAL_HEAP_SIZE.
   Then new macro now specify the global heap size in kilobytes.
* Updated documentations to reflect the new macro names.

For more deatils please see jerry-core/config.h.

JerryScript-DCO-1.0-Signed-off-by: Peter Gal pgal.u-szeged@partner.samsung.com

jerry-core/jmem/jmem-allocator-internal.h

@@ -28,7 +28,7 @@
  * @{
  * Valgrind-related options and headers
  */
-#ifdef JERRY_VALGRIND
+#if ENABLED (JERRY_VALGRIND)
 # include "memcheck.h"
 
 # define JMEM_VALGRIND_NOACCESS_SPACE(p, s)   VALGRIND_MAKE_MEM_NOACCESS((p), (s))
@@ -36,19 +36,19 @@
 # define JMEM_VALGRIND_DEFINED_SPACE(p, s)    VALGRIND_MAKE_MEM_DEFINED((p), (s))
 # define JMEM_VALGRIND_MALLOCLIKE_SPACE(p, s) VALGRIND_MALLOCLIKE_BLOCK((p), (s), 0, 0)
 # define JMEM_VALGRIND_FREELIKE_SPACE(p)      VALGRIND_FREELIKE_BLOCK((p), 0)
-#else /* !JERRY_VALGRIND */
+#else /* !ENABLED (JERRY_VALGRIND) */
 # define JMEM_VALGRIND_NOACCESS_SPACE(p, s)
 # define JMEM_VALGRIND_UNDEFINED_SPACE(p, s)
 # define JMEM_VALGRIND_DEFINED_SPACE(p, s)
 # define JMEM_VALGRIND_MALLOCLIKE_SPACE(p, s)
 # define JMEM_VALGRIND_FREELIKE_SPACE(p)
-#endif /* JERRY_VALGRIND */
+#endif /* ENABLED (JERRY_VALGRIND) */
 /** @} */
 
-#ifdef JMEM_STATS
+#if ENABLED (JERRY_MEM_STATS)
 void jmem_heap_stats_reset_peak (void);
 void jmem_heap_stats_print (void);
-#endif /* JMEM_STATS */
+#endif /* ENABLED (JERRY_MEM_STATS) */
 
 void jmem_heap_init (void);
 void jmem_heap_finalize (void);

jerry-core/jmem/jmem-allocator.c

@@ -24,7 +24,7 @@
 #define JMEM_ALLOCATOR_INTERNAL
 #include "jmem-allocator-internal.h"
 
-#ifdef JMEM_STATS
+#if ENABLED (JERRY_MEM_STATS)
 /**
  * Register byte code allocation.
  */
@@ -141,7 +141,7 @@ jmem_stats_free_property_bytes (size_t property_size)
   heap_stats->property_bytes -= property_size;
 } /* jmem_stats_free_property_bytes */
 
-#endif /* JMEM_STATS */
+#endif /* ENABLED (JERRY_MEM_STATS) */
 
 /**
  * Initialize memory allocators.
@@ -160,12 +160,12 @@ jmem_finalize (void)
 {
   jmem_pools_finalize ();
 
-#ifdef JMEM_STATS
+#if ENABLED (JERRY_MEM_STATS)
   if (JERRY_CONTEXT (jerry_init_flags) & ECMA_INIT_MEM_STATS)
   {
     jmem_heap_stats_print ();
   }
-#endif /* JMEM_STATS */
+#endif /* ENABLED (JERRY_MEM_STATS) */
 
   jmem_heap_finalize ();
 } /* jmem_finalize */
@@ -185,21 +185,21 @@ jmem_compress_pointer (const void *pointer_p) /**< pointer to compress */
 
   JERRY_ASSERT (uint_ptr % JMEM_ALIGNMENT == 0);
 
-#if defined (ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY) && defined (JERRY_CPOINTER_32_BIT)
+#if defined (ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY) && ENABLED (JERRY_CPOINTER_32_BIT)
   JERRY_ASSERT (((jmem_cpointer_t) uint_ptr) == uint_ptr);
-#else /* !ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY || !JERRY_CPOINTER_32_BIT */
+#else /* !ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY || !ENABLED (JERRY_CPOINTER_32_BIT) */
   const uintptr_t heap_start = (uintptr_t) &JERRY_HEAP_CONTEXT (first);
 
   uint_ptr -= heap_start;
   uint_ptr >>= JMEM_ALIGNMENT_LOG;
 
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   JERRY_ASSERT (uint_ptr <= UINT32_MAX);
-#else /* !JERRY_CPOINTER_32_BIT */
+#else /* !ENABLED (JERRY_CPOINTER_32_BIT) */
   JERRY_ASSERT (uint_ptr <= UINT16_MAX);
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
   JERRY_ASSERT (uint_ptr != JMEM_CP_NULL);
-#endif /* ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY && JERRY_CPOINTER_32_BIT */
+#endif /* ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY && ENABLED (JERRY_CPOINTER_32_BIT) */
 
   return (jmem_cpointer_t) uint_ptr;
 } /* jmem_compress_pointer */
@@ -218,16 +218,16 @@ jmem_decompress_pointer (uintptr_t compressed_pointer) /**< pointer to decompres
 
   JERRY_ASSERT (((jmem_cpointer_t) uint_ptr) == uint_ptr);
 
-#if defined (ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY) && defined (JERRY_CPOINTER_32_BIT)
+#if defined (ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY) && ENABLED (JERRY_CPOINTER_32_BIT)
   JERRY_ASSERT (uint_ptr % JMEM_ALIGNMENT == 0);
-#else /* !ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY || !JERRY_CPOINTER_32_BIT */
+#else /* !ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY || !ENABLED (JERRY_CPOINTER_32_BIT) */
   const uintptr_t heap_start = (uintptr_t) &JERRY_HEAP_CONTEXT (first);
 
   uint_ptr <<= JMEM_ALIGNMENT_LOG;
   uint_ptr += heap_start;
 
   JERRY_ASSERT (jmem_is_heap_pointer ((void *) uint_ptr));
-#endif /* ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY && JERRY_CPOINTER_32_BIT */
+#endif /* ECMA_VALUE_CAN_STORE_UINTPTR_VALUE_DIRECTLY && ENABLED (JERRY_CPOINTER_32_BIT) */
 
   return (void *) uint_ptr;
 } /* jmem_decompress_pointer */

jerry-core/jmem/jmem-heap.c

@@ -32,7 +32,7 @@
  * @{
  */
 
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
 /**
  * End of list marker.
  */
@@ -63,13 +63,13 @@ jmem_heap_get_region_end (jmem_heap_free_t *curr_p) /**< current region */
 {
   return (jmem_heap_free_t *)((uint8_t *) curr_p + curr_p->size);
 } /* jmem_heap_get_region_end */
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 
 /**
  * @{
  * JMEM_HEAP_STAT_xxx definitions
  */
-#ifdef JMEM_STATS
+#if ENABLED (JERRY_MEM_STATS)
 static void jmem_heap_stat_init (void);
 static void jmem_heap_stat_alloc (size_t num);
 static void jmem_heap_stat_free (size_t num);
@@ -78,7 +78,7 @@ static void jmem_heap_stat_free (size_t num);
 #define JMEM_HEAP_STAT_ALLOC(v1) jmem_heap_stat_alloc (v1)
 #define JMEM_HEAP_STAT_FREE(v1) jmem_heap_stat_free (v1)
 
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
 static void jmem_heap_stat_skip (void);
 static void jmem_heap_stat_nonskip (void);
 static void jmem_heap_stat_alloc_iter (void);
@@ -88,19 +88,19 @@ static void jmem_heap_stat_free_iter (void);
 #define JMEM_HEAP_STAT_NONSKIP() jmem_heap_stat_nonskip ()
 #define JMEM_HEAP_STAT_ALLOC_ITER() jmem_heap_stat_alloc_iter ()
 #define JMEM_HEAP_STAT_FREE_ITER() jmem_heap_stat_free_iter ()
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
-#else /* !JMEM_STATS */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
+#else /* !ENABLED (JERRY_MEM_STATS) */
 #define JMEM_HEAP_STAT_INIT()
 #define JMEM_HEAP_STAT_ALLOC(v1) JERRY_UNUSED (v1)
 #define JMEM_HEAP_STAT_FREE(v1) JERRY_UNUSED (v1)
 
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
 #define JMEM_HEAP_STAT_SKIP()
 #define JMEM_HEAP_STAT_NONSKIP()
 #define JMEM_HEAP_STAT_ALLOC_ITER()
 #define JMEM_HEAP_STAT_FREE_ITER()
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
-#endif /* JMEM_STATS */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
+#endif /* ENABLED (JERRY_MEM_STATS) */
 /** @} */
 
 /**
@@ -109,11 +109,11 @@ static void jmem_heap_stat_free_iter (void);
 void
 jmem_heap_init (void)
 {
-#ifndef JERRY_SYSTEM_ALLOCATOR
-#ifndef JERRY_CPOINTER_32_BIT
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
+#if !ENABLED (JERRY_CPOINTER_32_BIT)
   /* the maximum heap size for 16bit compressed pointers should be 512K */
   JERRY_ASSERT (((UINT16_MAX + 1) << JMEM_ALIGNMENT_LOG) >= JMEM_HEAP_SIZE);
-#endif /* !JERRY_CPOINTER_32_BIT */
+#endif /* !ENABLED (JERRY_CPOINTER_32_BIT) */
   JERRY_ASSERT ((uintptr_t) JERRY_HEAP_CONTEXT (area) % JMEM_ALIGNMENT == 0);
 
   JERRY_CONTEXT (jmem_heap_limit) = CONFIG_MEM_HEAP_DESIRED_LIMIT;
@@ -130,7 +130,7 @@ jmem_heap_init (void)
 
   JMEM_VALGRIND_NOACCESS_SPACE (JERRY_HEAP_CONTEXT (area), JMEM_HEAP_AREA_SIZE);
 
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
   JMEM_HEAP_STAT_INIT ();
 } /* jmem_heap_init */
 
@@ -141,9 +141,9 @@ void
 jmem_heap_finalize (void)
 {
   JERRY_ASSERT (JERRY_CONTEXT (jmem_heap_allocated_size) == 0);
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   JMEM_VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), JMEM_HEAP_SIZE);
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 } /* jmem_heap_finalize */
 
 /**
@@ -158,7 +158,7 @@ jmem_heap_finalize (void)
 static void * JERRY_ATTR_HOT
 jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block */
 {
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   /* Align size. */
   const size_t required_size = ((size + JMEM_ALIGNMENT - 1) / JMEM_ALIGNMENT) * JMEM_ALIGNMENT;
   jmem_heap_free_t *data_space_p = NULL;
@@ -281,7 +281,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
   JMEM_HEAP_STAT_ALLOC (size);
 
   return (void *) data_space_p;
-#else /* JERRY_SYSTEM_ALLOCATOR */
+#else /* ENABLED (JERRY_SYSTEM_ALLOCATOR) */
   JMEM_HEAP_STAT_ALLOC (size);
   JERRY_CONTEXT (jmem_heap_allocated_size) += size;
 
@@ -291,7 +291,7 @@ jmem_heap_alloc_block_internal (const size_t size) /**< size of requested block
   }
 
   return malloc (size);
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 } /* jmem_heap_alloc_block_internal */
 
 /**
@@ -315,9 +315,9 @@ jmem_heap_gc_and_alloc_block (const size_t size,      /**< required memory size
     return NULL;
   }
 
-#ifdef JMEM_GC_BEFORE_EACH_ALLOC
+#if ENABLED (JERRY_MEM_GC_BEFORE_EACH_ALLOC)
   jmem_run_free_unused_memory_callbacks (JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
-#endif /* JMEM_GC_BEFORE_EACH_ALLOC */
+#endif /* ENABLED (JERRY_MEM_GC_BEFORE_EACH_ALLOC) */
 
   if (JERRY_CONTEXT (jmem_heap_allocated_size) + size >= JERRY_CONTEXT (jmem_heap_limit))
   {
@@ -396,7 +396,7 @@ void JERRY_ATTR_HOT
 jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the block */
                       const size_t size) /**< size of allocated region */
 {
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   /* checking that ptr points to the heap */
   JERRY_ASSERT (jmem_is_heap_pointer (ptr));
   JERRY_ASSERT (size > 0);
@@ -492,7 +492,7 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
   JMEM_VALGRIND_NOACCESS_SPACE (&JERRY_HEAP_CONTEXT (first), sizeof (jmem_heap_free_t));
   JERRY_ASSERT (JERRY_CONTEXT (jmem_heap_limit) >= JERRY_CONTEXT (jmem_heap_allocated_size));
   JMEM_HEAP_STAT_FREE (size);
-#else /* JERRY_SYSTEM_ALLOCATOR */
+#else /* ENABLED (JERRY_SYSTEM_ALLOCATOR) */
   JMEM_HEAP_STAT_FREE (size);
   JERRY_CONTEXT (jmem_heap_allocated_size) -= size;
 
@@ -502,7 +502,7 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
   }
 
   free (ptr);
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 } /* jmem_heap_free_block */
 
 #ifndef JERRY_NDEBUG
@@ -518,17 +518,17 @@ jmem_heap_free_block (void *ptr, /**< pointer to beginning of data space of the
 bool
 jmem_is_heap_pointer (const void *pointer) /**< pointer */
 {
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   return ((uint8_t *) pointer >= JERRY_HEAP_CONTEXT (area)
           && (uint8_t *) pointer <= (JERRY_HEAP_CONTEXT (area) + JMEM_HEAP_AREA_SIZE));
-#else /* JERRY_SYSTEM_ALLOCATOR */
+#else /* ENABLED (JERRY_SYSTEM_ALLOCATOR) */
   JERRY_UNUSED (pointer);
   return true;
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 } /* jmem_is_heap_pointer */
 #endif /* !JERRY_NDEBUG */
 
-#ifdef JMEM_STATS
+#if ENABLED (JERRY_MEM_STATS)
 /**
  * Get heap memory usage statistics
  */
@@ -549,10 +549,10 @@ jmem_heap_stats_print (void)
   jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
 
   JERRY_DEBUG_MSG ("Heap stats:\n");
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   JERRY_DEBUG_MSG ("  Heap size = %zu bytes\n",
                    heap_stats->size);
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
   JERRY_DEBUG_MSG ("  Allocated = %zu bytes\n"
                    "  Peak allocated = %zu bytes\n"
                    "  Waste = %zu bytes\n"
@@ -577,7 +577,7 @@ jmem_heap_stats_print (void)
                    heap_stats->peak_object_bytes,
                    heap_stats->property_bytes,
                    heap_stats->peak_property_bytes);
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   JERRY_DEBUG_MSG ("  Skip-ahead ratio = %zu.%04zu\n"
                    "  Average alloc iteration = %zu.%04zu\n"
                    "  Average free iteration = %zu.%04zu\n",
@@ -587,7 +587,7 @@ jmem_heap_stats_print (void)
                    heap_stats->alloc_iter_count % heap_stats->alloc_count * 10000 / heap_stats->alloc_count,
                    heap_stats->free_iter_count / heap_stats->free_count,
                    heap_stats->free_iter_count % heap_stats->free_count * 10000 / heap_stats->free_count);
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 } /* jmem_heap_stats_print */
 
 /**
@@ -596,9 +596,9 @@ jmem_heap_stats_print (void)
 static void
 jmem_heap_stat_init (void)
 {
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
   JERRY_CONTEXT (jmem_heap_stats).size = JMEM_HEAP_AREA_SIZE;
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
 } /* jmem_heap_stat_init */
 
 /**
@@ -643,7 +643,7 @@ jmem_heap_stat_free (size_t size) /**< Size of freed block */
   heap_stats->waste_bytes -= waste_bytes;
 } /* jmem_heap_stat_free */
 
-#ifndef JERRY_SYSTEM_ALLOCATOR
+#if !ENABLED (JERRY_SYSTEM_ALLOCATOR)
 /**
  * Counts number of skip-aheads during insertion of free block
  */
@@ -679,8 +679,8 @@ jmem_heap_stat_free_iter (void)
 {
   JERRY_CONTEXT (jmem_heap_stats).free_iter_count++;
 } /* jmem_heap_stat_free_iter */
-#endif /* !JERRY_SYSTEM_ALLOCATOR */
-#endif /* JMEM_STATS */
+#endif /* !ENABLED (JERRY_SYSTEM_ALLOCATOR) */
+#endif /* ENABLED (JERRY_MEM_STATS) */
 
 /**
  * @}

jerry-core/jmem/jmem-poolman.c

@@ -40,9 +40,9 @@ jmem_pools_finalize (void)
   jmem_pools_collect_empty ();
 
   JERRY_ASSERT (JERRY_CONTEXT (jmem_free_8_byte_chunk_p) == NULL);
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   JERRY_ASSERT (JERRY_CONTEXT (jmem_free_16_byte_chunk_p) == NULL);
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 } /* jmem_pools_finalize */
 
 /**
@@ -54,16 +54,16 @@ jmem_pools_finalize (void)
 inline void * JERRY_ATTR_HOT JERRY_ATTR_ALWAYS_INLINE
 jmem_pools_alloc (size_t size) /**< size of the chunk */
 {
-#ifdef JMEM_GC_BEFORE_EACH_ALLOC
+#if ENABLED (JERRY_MEM_GC_BEFORE_EACH_ALLOC)
   jmem_run_free_unused_memory_callbacks (JMEM_FREE_UNUSED_MEMORY_SEVERITY_HIGH);
-#endif /* JMEM_GC_BEFORE_EACH_ALLOC */
+#endif /* ENABLED (JERRY_MEM_GC_BEFORE_EACH_ALLOC) */
 
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   if (size <= 8)
   {
-#else /* !JERRY_CPOINTER_32_BIT */
+#else /* !ENABLED (JERRY_CPOINTER_32_BIT) */
     JERRY_ASSERT (size <= 8);
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 
     if (JERRY_CONTEXT (jmem_free_8_byte_chunk_p) != NULL)
     {
@@ -82,7 +82,7 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
       return (void *) jmem_heap_alloc_block (8);
     }
 
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   }
 
   JERRY_ASSERT (size <= 16);
@@ -103,7 +103,7 @@ jmem_pools_alloc (size_t size) /**< size of the chunk */
   {
     return (void *) jmem_heap_alloc_block (16);
   }
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 } /* jmem_pools_alloc */
 
 /**
@@ -119,17 +119,17 @@ jmem_pools_free (void *chunk_p, /**< pointer to the chunk */
 
   JMEM_VALGRIND_DEFINED_SPACE (chunk_to_free_p, size);
 
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   if (size <= 8)
   {
-#else /* !JERRY_CPOINTER_32_BIT */
+#else /* !ENABLED (JERRY_CPOINTER_32_BIT) */
     JERRY_ASSERT (size <= 8);
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 
     chunk_to_free_p->next_p = JERRY_CONTEXT (jmem_free_8_byte_chunk_p);
     JERRY_CONTEXT (jmem_free_8_byte_chunk_p) = chunk_to_free_p;
 
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   }
   else
   {
@@ -138,7 +138,7 @@ jmem_pools_free (void *chunk_p, /**< pointer to the chunk */
     chunk_to_free_p->next_p = JERRY_CONTEXT (jmem_free_16_byte_chunk_p);
     JERRY_CONTEXT (jmem_free_16_byte_chunk_p) = chunk_to_free_p;
   }
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 
   JMEM_VALGRIND_NOACCESS_SPACE (chunk_to_free_p, size);
 } /* jmem_pools_free */
@@ -162,7 +162,7 @@ jmem_pools_collect_empty (void)
     chunk_p = next_p;
   }
 
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
   chunk_p = JERRY_CONTEXT (jmem_free_16_byte_chunk_p);
   JERRY_CONTEXT (jmem_free_16_byte_chunk_p) = NULL;
 
@@ -175,7 +175,7 @@ jmem_pools_collect_empty (void)
     jmem_heap_free_block (chunk_p, 16);
     chunk_p = next_p;
   }
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 } /* jmem_pools_collect_empty */
 
 /**

jerry-core/jmem/jmem.h

@@ -63,11 +63,11 @@
 /**
  * Compressed pointer
  */
-#ifdef JERRY_CPOINTER_32_BIT
+#if ENABLED (JERRY_CPOINTER_32_BIT)
 typedef uint32_t jmem_cpointer_t;
-#else /* !JERRY_CPOINTER_32_BIT */
+#else /* !ENABLED (JERRY_CPOINTER_32_BIT) */
 typedef uint16_t jmem_cpointer_t;
-#endif /* JERRY_CPOINTER_32_BIT */
+#endif /* ENABLED (JERRY_CPOINTER_32_BIT) */
 
 /**
  * Severity of a 'try give memory back' request
@@ -108,7 +108,7 @@ void *jmem_heap_alloc_block (const size_t size);
 void *jmem_heap_alloc_block_null_on_error (const size_t size);
 void jmem_heap_free_block (void *ptr, const size_t size);
 
-#ifdef JMEM_STATS
+#if ENABLED (JERRY_MEM_STATS)
 /**
  * Heap memory usage statistics
  */
@@ -154,7 +154,7 @@ void jmem_stats_allocate_property_bytes (size_t property_size);
 void jmem_stats_free_property_bytes (size_t property_size);
 
 void jmem_heap_get_stats (jmem_heap_stats_t *);
-#endif /* JMEM_STATS */
+#endif /* ENABLED (JERRY_MEM_STATS) */
 
 jmem_cpointer_t JERRY_ATTR_PURE jmem_compress_pointer (const void *pointer_p);
 void * JERRY_ATTR_PURE jmem_decompress_pointer (uintptr_t compressed_pointer);