Rework CMake options to use the new macro config format

jerry-core/CMakeLists.txt

@@ -20,25 +20,25 @@ project (${JERRY_CORE_NAME} C)
 set(ENABLE_ALL_IN_ONE               OFF     CACHE BOOL   "Enable all-in-one build?")
 
 # Optional features
-set(FEATURE_CPOINTER_32_BIT         OFF     CACHE BOOL   "Enable 32 bit compressed pointers?")
-set(FEATURE_DEBUGGER                OFF     CACHE BOOL   "Enable JerryScript debugger?")
-set(FEATURE_ERROR_MESSAGES          OFF     CACHE BOOL   "Enable error messages?")
-set(FEATURE_EXTERNAL_CONTEXT        OFF     CACHE BOOL   "Enable external context?")
-set(FEATURE_JS_PARSER               ON      CACHE BOOL   "Enable js-parser?")
-set(FEATURE_LINE_INFO               OFF     CACHE BOOL   "Enable line info?")
-set(FEATURE_LOGGING                 OFF     CACHE BOOL   "Enable logging?")
-set(FEATURE_MEM_STATS               OFF     CACHE BOOL   "Enable memory statistics?")
-set(FEATURE_MEM_STRESS_TEST         OFF     CACHE BOOL   "Enable mem-stress test?")
-set(FEATURE_PARSER_DUMP             OFF     CACHE BOOL   "Enable parser byte-code dumps?")
-set(FEATURE_PROFILE                 "es5.1" CACHE STRING "Use default or other profile?")
-set(FEATURE_REGEXP_STRICT_MODE      OFF     CACHE BOOL   "Enable regexp strict mode?")
-set(FEATURE_REGEXP_DUMP             OFF     CACHE BOOL   "Enable regexp byte-code dumps?")
-set(FEATURE_SNAPSHOT_EXEC           OFF     CACHE BOOL   "Enable executing snapshot files?")
-set(FEATURE_SNAPSHOT_SAVE           OFF     CACHE BOOL   "Enable saving snapshot files?")
-set(FEATURE_SYSTEM_ALLOCATOR        OFF     CACHE BOOL   "Enable system allocator?")
-set(FEATURE_VALGRIND                OFF     CACHE BOOL   "Enable Valgrind support?")
-set(FEATURE_VM_EXEC_STOP            OFF     CACHE BOOL   "Enable VM execution stopping?")
-set(JERRY_GLOBAL_HEAP_SIZE          "512"   CACHE STRING "Size of memory heap, in kilobytes")
+set(JERRY_CPOINTER_32_BIT           OFF     CACHE BOOL   "Enable 32 bit compressed pointers?")
+set(JERRY_DEBUGGER                  OFF     CACHE BOOL   "Enable JerryScript debugger?")
+set(JERRY_ERROR_MESSAGES            OFF     CACHE BOOL   "Enable error messages?")
+set(JERRY_EXTERNAL_CONTEXT          OFF     CACHE BOOL   "Enable external context?")
+set(JERRY_PARSER                    ON      CACHE BOOL   "Enable javascript-parser?")
+set(JERRY_LINE_INFO                 OFF     CACHE BOOL   "Enable line info?")
+set(JERRY_LOGGING                   OFF     CACHE BOOL   "Enable logging?")
+set(JERRY_MEM_STATS                 OFF     CACHE BOOL   "Enable memory statistics?")
+set(JERRY_MEM_GC_BEFORE_EACH_ALLOC  OFF     CACHE BOOL   "Enable mem-stress test?")
+set(JERRY_PARSER_DUMP_BYTE_CODE     OFF     CACHE BOOL   "Enable parser byte-code dumps?")
+set(JERRY_PROFILE                   "es5.1" CACHE STRING "Use default or other profile?")
+set(JERRY_REGEXP_STRICT_MODE        OFF     CACHE BOOL   "Enable regexp strict mode?")
+set(JERRY_REGEXP_DUMP_BYTE_CODE     OFF     CACHE BOOL   "Enable regexp byte-code dumps?")
+set(JERRY_SNAPSHOT_EXEC             OFF     CACHE BOOL   "Enable executing snapshot files?")
+set(JERRY_SNAPSHOT_SAVE             OFF     CACHE BOOL   "Enable saving snapshot files?")
+set(JERRY_SYSTEM_ALLOCATOR          OFF     CACHE BOOL   "Enable system allocator?")
+set(JERRY_VALGRIND                  OFF     CACHE BOOL   "Enable Valgrind support?")
+set(JERRY_VM_EXEC_STOP              OFF     CACHE BOOL   "Enable VM execution stopping?")
+set(JERRY_GLOBAL_HEAP_SIZE          "(512)" CACHE STRING "Size of memory heap, in kilobytes")
 set(JERRY_REGEXP_RECURSION_LIMIT    "0"     CACHE STRING "Limit of regexp recursion depth")
 set(JERRY_CALL_STACK_LIMIT          "0"     CACHE STRING "Limit of function call recursion depth")
 
@@ -49,61 +49,61 @@ if(USING_MSVC)
   set(ENABLE_ALL_IN_ONE_MESSAGE " (FORCED BY COMPILER)")
 endif()
 
-if(FEATURE_SYSTEM_ALLOCATOR)
-  set(FEATURE_CPOINTER_32_BIT ON)
+if(JERRY_SYSTEM_ALLOCATOR)
+  set(JERRY_CPOINTER_32_BIT ON)
 
-  set(FEATURE_CPOINTER_32_BIT_MESSAGE " (FORCED BY SYSTEM ALLOCATOR)")
+  set(JERRY_CPOINTER_32_BIT_MESSAGE " (FORCED BY SYSTEM ALLOCATOR)")
 endif()
 
 if (JERRY_GLOBAL_HEAP_SIZE GREATER 512)
-  set(FEATURE_CPOINTER_32_BIT ON)
+  set(JERRY_CPOINTER_32_BIT ON)
 
-  set(FEATURE_CPOINTER_32_BIT_MESSAGE " (FORCED BY HEAP SIZE)")
+  set(JERRY_CPOINTER_32_BIT_MESSAGE " (FORCED BY HEAP SIZE)")
 endif()
 
-if(NOT FEATURE_JS_PARSER)
-  set(FEATURE_SNAPSHOT_EXEC ON)
-  set(FEATURE_PARSER_DUMP   OFF)
+if(NOT JERRY_PARSER)
+  set(JERRY_SNAPSHOT_EXEC ON)
+  set(JERRY_PARSER_DUMP   OFF)
 
-  set(FEATURE_SNAPSHOT_EXEC_MESSAGE " (FORCED BY DISABLED JS PARSER)")
-  set(FEATURE_PARSER_DUMP_MESSAGE   " (FORCED BY DISABLED JS PARSER)")
+  set(JERRY_SNAPSHOT_EXEC_MESSAGE " (FORCED BY DISABLED JS PARSER)")
+  set(JERRY_PARSER_DUMP_MESSAGE   " (FORCED BY DISABLED JS PARSER)")
 endif()
 
 if(JERRY_CMDLINE_SNAPSHOT)
-  set(FEATURE_SNAPSHOT_SAVE ON)
+  set(JERRY_SNAPSHOT_SAVE ON)
 
-  set(FEATURE_SNAPSHOT_SAVE_MESSAGE " (FORCED BY SNAPSHOT TOOL)")
+  set(JERRY_SNAPSHOT_SAVE_MESSAGE " (FORCED BY SNAPSHOT TOOL)")
 endif()
 
-if(FEATURE_MEM_STATS OR FEATURE_PARSER_DUMP OR FEATURE_REGEXP_DUMP)
-  set(FEATURE_LOGGING ON)
+if(JERRY_MEM_STATS OR JERRY_PARSER_DUMP_BYTE_CODE OR JERRY_REGEXP_DUMP_BYTE_CODE)
+  set(JERRY_LOGGING ON)
 
-  set(FEATURE_LOGGING_MESSAGE " (FORCED BY STATS OR DUMP)")
+  set(JERRYRE_LOGGING_MESSAGE " (FORCED BY STATS OR DUMP)")
 endif()
 
 # Status messages
-message(STATUS "ENABLE_ALL_IN_ONE            " ${ENABLE_ALL_IN_ONE} ${ENABLE_ALL_IN_ONE_MESSAGE})
-message(STATUS "FEATURE_CPOINTER_32_BIT      " ${FEATURE_CPOINTER_32_BIT} ${FEATURE_CPOINTER_32_BIT_MESSAGE})
-message(STATUS "FEATURE_DEBUGGER             " ${FEATURE_DEBUGGER})
-message(STATUS "FEATURE_ERROR_MESSAGES       " ${FEATURE_ERROR_MESSAGES})
-message(STATUS "FEATURE_EXTERNAL_CONTEXT     " ${FEATURE_EXTERNAL_CONTEXT})
-message(STATUS "FEATURE_JS_PARSER            " ${FEATURE_JS_PARSER})
-message(STATUS "FEATURE_LINE_INFO            " ${FEATURE_LINE_INFO})
-message(STATUS "FEATURE_LOGGING              " ${FEATURE_LOGGING} ${FEATURE_LOGGING_MESSAGE})
-message(STATUS "FEATURE_MEM_STATS            " ${FEATURE_MEM_STATS})
-message(STATUS "FEATURE_MEM_STRESS_TEST      " ${FEATURE_MEM_STRESS_TEST})
-message(STATUS "FEATURE_PARSER_DUMP          " ${FEATURE_PARSER_DUMP} ${FEATURE_PARSER_DUMP_MESSAGE})
-message(STATUS "FEATURE_PROFILE              " ${FEATURE_PROFILE})
-message(STATUS "FEATURE_REGEXP_STRICT_MODE   " ${FEATURE_REGEXP_STRICT_MODE})
-message(STATUS "FEATURE_REGEXP_DUMP          " ${FEATURE_REGEXP_DUMP})
-message(STATUS "FEATURE_SNAPSHOT_EXEC        " ${FEATURE_SNAPSHOT_EXEC} ${FEATURE_SNAPSHOT_EXEC_MESSAGE})
-message(STATUS "FEATURE_SNAPSHOT_SAVE        " ${FEATURE_SNAPSHOT_SAVE} ${FEATURE_SNAPSHOT_SAVE_MESSAGE})
-message(STATUS "FEATURE_SYSTEM_ALLOCATOR     " ${FEATURE_SYSTEM_ALLOCATOR})
-message(STATUS "FEATURE_VALGRIND             " ${FEATURE_VALGRIND})
-message(STATUS "FEATURE_VM_EXEC_STOP         " ${FEATURE_VM_EXEC_STOP})
-message(STATUS "JERRY_GLOBAL_HEAP_SIZE       " ${JERRY_GLOBAL_HEAP_SIZE})
-message(STATUS "JERRY_REGEXP_RECURSION_LIMIT " ${JERRY_REGEXP_RECURSION_LIMIT})
-message(STATUS "JERRY_CALL_STACK_LIMIT       " ${JERRY_CALL_STACK_LIMIT})
+message(STATUS "ENABLE_ALL_IN_ONE              " ${ENABLE_ALL_IN_ONE} ${ENABLE_ALL_IN_ONE_MESSAGE})
+message(STATUS "JERRY_CPOINTER_32_BIT          " ${JERRY_CPOINTER_32_BIT} ${JERRY_CPOINTER_32_BIT_MESSAGE})
+message(STATUS "JERRY_DEBUGGER                 " ${JERRY_DEBUGGER})
+message(STATUS "JERRY_ERROR_MESSAGES           " ${JERRY_ERROR_MESSAGES})
+message(STATUS "JERRY_EXTERNAL_CONTEXT         " ${JERRY_EXTERNAL_CONTEXT})
+message(STATUS "JERRY_PARSER                   " ${JERRY_PARSER})
+message(STATUS "JERRY_LINE_INFO                " ${JERRY_LINE_INFO})
+message(STATUS "JERRY_LOGGING                  " ${JERRY_LOGGING} ${JERRY_LOGGING_MESSAGE})
+message(STATUS "JERRY_MEM_STATS                " ${JERRY_MEM_STATS})
+message(STATUS "JERRY_MEM_GC_BEFORE_EACH_ALLOC " ${JERRY_MEM_GC_BEFORE_EACH_ALLOC})
+message(STATUS "JERRY_PARSER_DUMP_BYTE_CODE    " ${JERRY_PARSER_DUMP_BYTE_CODE} ${JERRY_PARSER_DUMP_MESSAGE})
+message(STATUS "JERRY_PROFILE                  " ${JERRY_PROFILE})
+message(STATUS "JERRY_REGEXP_STRICT_MODE       " ${JERRY_REGEXP_STRICT_MODE})
+message(STATUS "JERRY_REGEXP_DUMP_BYTE_CODE    " ${JERRY_REGEXP_DUMP_BYTE_CODE})
+message(STATUS "JERRY_SNAPSHOT_EXEC            " ${JERRY_SNAPSHOT_EXEC} ${JERRY_SNAPSHOT_EXEC_MESSAGE})
+message(STATUS "JERRY_SNAPSHOT_SAVE            " ${JERRY_SNAPSHOT_SAVE} ${JERRY_SNAPSHOT_SAVE_MESSAGE})
+message(STATUS "JERRY_SYSTEM_ALLOCATOR         " ${JERRY_SYSTEM_ALLOCATOR})
+message(STATUS "JERRY_VALGRIND                 " ${JERRY_VALGRIND})
+message(STATUS "JERRY_VM_EXEC_STOP             " ${JERRY_VM_EXEC_STOP})
+message(STATUS "JERRY_GLOBAL_HEAP_SIZE         " ${JERRY_GLOBAL_HEAP_SIZE})
+message(STATUS "JERRY_REGEXP_RECURSION_LIMIT   " ${JERRY_REGEXP_RECURSION_LIMIT})
+message(STATUS "JERRY_CALL_STACK_LIMIT         " ${JERRY_CALL_STACK_LIMIT})
 
 # Include directories
 set(INCLUDE_CORE_PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
@@ -218,75 +218,62 @@ if(DEFINED JERRY_ATTR_GLOBAL_HEAP)
   set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_ATTR_GLOBAL_HEAP=${JERRY_ATTR_GLOBAL_HEAP})
 endif()
 
+# Helper macro to set 0/1 switch as Jerry Defines
+macro(jerry_add_define01 NAME)
+  if(${NAME})
+    set(DEFINES_JERRY ${DEFINES_JERRY} ${NAME}=1)
+  else()
+    set(DEFINES_JERRY ${DEFINES_JERRY} ${NAME}=0)
+  endif()
+endmacro(jerry_add_define01)
+
 # Checks the optional features
 # Enable 32 bit cpointers
-if(FEATURE_CPOINTER_32_BIT)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_CPOINTER_32_BIT=1)
-endif()
+jerry_add_define01(JERRY_CPOINTER_32_BIT)
 
 # Fill error messages for builtin error objects
-if(FEATURE_ERROR_MESSAGES)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_ERROR_MESSAGES=1)
-endif()
+jerry_add_define01(JERRY_ERROR_MESSAGES)
 
 # Use external context instead of static one
-if(FEATURE_EXTERNAL_CONTEXT)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_EXTERNAL_CONTEXT=1)
-endif()
+jerry_add_define01(JERRY_EXTERNAL_CONTEXT)
 
 # JS-Parser
-if(NOT FEATURE_JS_PARSER)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_PARSER=0)
-endif()
+jerry_add_define01(JERRY_PARSER)
 
 # JS line info
-if(FEATURE_LINE_INFO)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_LINE_INFO=1)
-endif()
+jerry_add_define01(JERRY_LINE_INFO)
 
 # Logging
-if(FEATURE_LOGGING)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_LOGGING=1)
-endif()
+jerry_add_define01(JERRY_LOGGING)
 
 # Memory statistics
-if(FEATURE_MEM_STATS)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_MEM_STATS=1)
-endif()
+jerry_add_define01(JERRY_MEM_STATS)
 
 # Enable debugger
-if(FEATURE_DEBUGGER)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_DEBUGGER=1)
-endif()
+jerry_add_define01(JERRY_DEBUGGER)
 
 # Memory management stress-test mode
-if(FEATURE_MEM_STRESS_TEST)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_MEM_GC_BEFORE_EACH_ALLOC=1)
-endif()
+jerry_add_define01(JERRY_MEM_GC_BEFORE_EACH_ALLOC)
 
 # Parser byte-code dumps
-if(FEATURE_PARSER_DUMP)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_PARSER_DUMP_BYTE_CODE=1)
-endif()
+jerry_add_define01(JERRY_PARSER_DUMP_BYTE_CODE)
 
 # Profile
-if (NOT IS_ABSOLUTE ${FEATURE_PROFILE})
-  set(FEATURE_PROFILE "${CMAKE_CURRENT_SOURCE_DIR}/profiles/${FEATURE_PROFILE}.profile")
+if (NOT IS_ABSOLUTE ${JERRY_PROFILE})
+  set(JERRY_PROFILE "${CMAKE_CURRENT_SOURCE_DIR}/profiles/${JERRY_PROFILE}.profile")
 endif()
 
-if(EXISTS ${FEATURE_PROFILE})
-  file(READ "${FEATURE_PROFILE}" PROFILE_SETTINGS)
+if(EXISTS ${JERRY_PROFILE})
+  file(READ "${JERRY_PROFILE}" PROFILE_SETTINGS)
   string(REGEX REPLACE "^#.*$" "" PROFILE_SETTINGS "${PROFILE_SETTINGS}")
   string(REGEX REPLACE "[\r|\n]" ";" PROFILE_SETTINGS "${PROFILE_SETTINGS}")
   set(DEFINES_JERRY ${DEFINES_JERRY} ${PROFILE_SETTINGS})
 else()
-  message(FATAL_ERROR "Profile file: '${FEATURE_PROFILE}' doesn't exist!")
+  message(FATAL_ERROR "Profile file: '${JERRY_PROFILE}' doesn't exist!")
 endif()
 
 # RegExp strict mode
-if(FEATURE_REGEXP_STRICT_MODE)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_REGEXP_STRICT_MODE=1)
-endif()
+jerry_add_define01(JERRY_REGEXP_STRICT_MODE)
 
 # RegExp recursion depth limit
 if(JERRY_REGEXP_RECURSION_LIMIT)
@@ -299,35 +286,25 @@ if(JERRY_CALL_STACK_LIMIT)
 endif()
 
 # RegExp byte-code dumps
-if(FEATURE_REGEXP_DUMP)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_REGEXP_DUMP_BYTE_CODE=1)
-endif()
+jerry_add_define01(JERRY_REGEXP_DUMP_BYTE_CODE)
 
 # Snapshot exec
-if(FEATURE_SNAPSHOT_EXEC)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_SNAPSHOT_EXEC=1)
-endif()
+jerry_add_define01(JERRY_SNAPSHOT_EXEC)
 
 # Snapshot save
-if(FEATURE_SNAPSHOT_SAVE)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_SNAPSHOT_SAVE=1)
-endif()
+jerry_add_define01(JERRY_SNAPSHOT_SAVE)
 
 # Enable system allocator
-if(FEATURE_SYSTEM_ALLOCATOR)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_SYSTEM_ALLOCATOR=1)
-endif()
+jerry_add_define01(JERRY_SYSTEM_ALLOCATOR)
 
 # Valgrind
-if(FEATURE_VALGRIND)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_VALGRIND=1)
+jerry_add_define01(JERRY_VALGRIND)
+if(JERRY_VALGRIND)
   set(INCLUDE_CORE_PRIVATE ${INCLUDE_CORE_PRIVATE} ${INCLUDE_THIRD_PARTY_VALGRIND})
 endif()
 
 # Enable VM execution stopping
-if (FEATURE_VM_EXEC_STOP)
-  set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_VM_EXEC_STOP=1)
-endif()
+jerry_add_define01(JERRY_VM_EXEC_STOP)
 
 # Size of heap
 set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_GLOBAL_HEAP_SIZE=${JERRY_GLOBAL_HEAP_SIZE})

targets/particle/Makefile.particle

@@ -47,7 +47,7 @@ jerrycore:
 	 -DENABLE_ALL_IN_ONE=OFF \
 	 -DJERRY_LIBM=OFF \
 	 -DJERRY_CMDLINE=OFF \
-	 -DFEATURE_PROFILE=minimal \
+	 -DJERRY_PROFILE=minimal \
 	 -DENABLE_STRIP=OFF \
 	 -DEXTERNAL_COMPILE_FLAGS="$(EXT_CFLAGS)" \
 	 -DJERRY_GLOBAL_HEAP_SIZE=$(JERRYHEAP)

targets/zephyr/Makefile.zephyr

@@ -84,8 +84,8 @@ endif
 	 -DENABLE_LTO=OFF \
 	 -DENABLE_ALL_IN_ONE=OFF \
 	 -DJERRY_CMDLINE=OFF \
-	 -DFEATURE_PROFILE=$(JERRYPROFILE) \
-	 -DFEATURE_ERROR_MESSAGES=ON \
+	 -DJERRY_PROFILE=$(JERRYPROFILE) \
+	 -DJERRY_ERROR_MESSAGES=ON \
 	 -DCMAKE_BUILD_TYPE=MinSizeRel \
 	 -DCMAKE_VERBOSE_MAKEFILE=$(V) \
 	 -DJERRY_GLOBAL_HEAP_SIZE=$(JERRYHEAP) \

tools/build.py

@@ -194,27 +194,27 @@ def build_options_append(cmakeopt, cliarg):
 
     # jerry-core options
     build_options_append('ENABLE_ALL_IN_ONE', arguments.all_in_one)
-    build_options_append('FEATURE_CPOINTER_32_BIT', arguments.cpointer_32bit)
-    build_options_append('FEATURE_ERROR_MESSAGES', arguments.error_messages)
-    build_options_append('FEATURE_EXTERNAL_CONTEXT', arguments.external_context)
-    build_options_append('FEATURE_DEBUGGER', arguments.jerry_debugger)
-    build_options_append('FEATURE_JS_PARSER', arguments.js_parser)
-    build_options_append('FEATURE_LINE_INFO', arguments.line_info)
-    build_options_append('FEATURE_LOGGING', arguments.logging)
+    build_options_append('JERRY_CPOINTER_32_BIT', arguments.cpointer_32bit)
+    build_options_append('JERRY_ERROR_MESSAGES', arguments.error_messages)
+    build_options_append('JERRY_EXTERNAL_CONTEXT', arguments.external_context)
+    build_options_append('JERRY_DEBUGGER', arguments.jerry_debugger)
+    build_options_append('JERRY_PARSER', arguments.js_parser)
+    build_options_append('JERRY_LINE_INFO', arguments.line_info)
+    build_options_append('JERRY_LOGGING', arguments.logging)
     build_options_append('JERRY_GLOBAL_HEAP_SIZE', arguments.mem_heap)
-    build_options_append('FEATURE_MEM_STATS', arguments.mem_stats)
-    build_options_append('FEATURE_MEM_STRESS_TEST', arguments.mem_stress_test)
-    build_options_append('FEATURE_PROFILE', arguments.profile)
-    build_options_append('FEATURE_REGEXP_STRICT_MODE', arguments.regexp_strict_mode)
+    build_options_append('JERRY_MEM_STATS', arguments.mem_stats)
+    build_options_append('JERRY_MEM_GC_BEFORE_EACH_ALLOC', arguments.mem_stress_test)
+    build_options_append('JERRY_PROFILE', arguments.profile)
+    build_options_append('JERRY_REGEXP_STRICT_MODE', arguments.regexp_strict_mode)
     build_options_append('JERRY_REGEXP_RECURSION_LIMIT', arguments.regexp_recursion_limit)
     build_options_append('JERRY_CALL_STACK_LIMIT', arguments.call_stack_limit)
-    build_options_append('FEATURE_PARSER_DUMP', arguments.show_opcodes)
-    build_options_append('FEATURE_REGEXP_DUMP', arguments.show_regexp_opcodes)
-    build_options_append('FEATURE_SNAPSHOT_EXEC', arguments.snapshot_exec)
-    build_options_append('FEATURE_SNAPSHOT_SAVE', arguments.snapshot_save)
-    build_options_append('FEATURE_SYSTEM_ALLOCATOR', arguments.system_allocator)
-    build_options_append('FEATURE_VALGRIND', arguments.valgrind)
-    build_options_append('FEATURE_VM_EXEC_STOP', arguments.vm_exec_stop)
+    build_options_append('JERRY_PARSER_DUMP_BYTE_CODE', arguments.show_opcodes)
+    build_options_append('JERRY_REGEXP_DUMP_BYTE_CODE', arguments.show_regexp_opcodes)
+    build_options_append('JERRY_SNAPSHOT_EXEC', arguments.snapshot_exec)
+    build_options_append('JERRY_SNAPSHOT_SAVE', arguments.snapshot_save)
+    build_options_append('JERRY_SYSTEM_ALLOCATOR', arguments.system_allocator)
+    build_options_append('JERRY_VALGRIND', arguments.valgrind)
+    build_options_append('JERRY_VM_EXEC_STOP', arguments.vm_exec_stop)
 
     # jerry-main options
     build_options_append('ENABLE_LINK_MAP', arguments.link_map)