Nuttx build support.

CMakeLists.txt

@@ -66,15 +66,17 @@ project (Jerry CXX C ASM)
 
  if("${PLATFORM}" STREQUAL "LINUX")
   set(PLATFORM_EXT "LINUX")
+  set(EXTERNAL_BUILD FALSE)
 
   option(STRIP_RELEASE_BINARY "Strip symbols from release binaries" ON)
  elseif("${PLATFORM}" STREQUAL "MCU")
   set(PLATFORM_EXT "MCU_${CMAKE_SYSTEM_VERSION}")
+  set(EXTERNAL_BUILD FALSE)
 
   option(STRIP_RELEASE_BINARY "Strip symbols from release binaries" OFF)
   set(MCU_SCRIPT_FILE "tests/blinky.js" CACHE STRING "Script to run on MCU")
- elseif("${PLATFORM}" STREQUAL "EXTERNAL")
+ elseif("${PLATFORM}" STREQUAL "NUTTX")
-  set(PLATFORM_EXT "EXTERNAL")
+  set(PLATFORM_EXT "NUTTX")
   set(EXTERNAL_BUILD TRUE)
 
   set(EXTERNAL_LIBC_INTERFACE "UNDEFINED" CACHE STRING "Path to external libc's include directory")
@@ -87,8 +89,12 @@ project (Jerry CXX C ASM)
   set(MCU_SCRIPT_GENERATED_HEADER ${CMAKE_BINARY_DIR}/generated.h)
 
 # Should we use external libc?
- if(NOT DEFINED EXTERNAL_LIBC_INTERFACE AND NOT EXTERNAL_LIBC_INTERFACE EQUAL "UNDEFINED")
+ if(NOT DEFINED EXTERNAL_LIBC_INTERFACE OR EXTERNAL_LIBC_INTERFACE STREQUAL "UNDEFINED")
   set(USE_EXTERNAL_LIBC FALSE)
+
+  if(${EXTERNAL_BUILD})
+   message(FATAL_ERROR "Currently, external build with Jerry's libc is not supported")
+  endif()
  else()
   set(USE_EXTERNAL_LIBC TRUE)
  endif()
@@ -145,6 +151,10 @@ project (Jerry CXX C ASM)
       "COMPACT_PROFILE"
       "COMPACT_PROFILE_MINIMAL")
 
+  # Nuttx
+   set(MODIFIERS_LISTS_NUTTX
+       ${MODIFIERS_LISTS_LINUX})
+
 # Compiler / Linker flags
  set(COMPILE_FLAGS_JERRY "-flto -fno-fat-lto-objects -fno-builtin")
  set(LINKER_FLAGS_COMMON "-flto")
@@ -208,6 +218,9 @@ project (Jerry CXX C ASM)
     # stm32f4
      set(SOURCE_JERRY_STANDALONE_MAIN_MCU_STM32F4 main-mcu.cpp)
 
+   # Nuttx
+    set(SOURCE_JERRY_STANDALONE_MAIN_NUTTX main-nuttx.cpp)
+
  # Unit tests main modules
   file(GLOB SOURCE_UNIT_TEST_MAIN_MODULES tests/unit/*.cpp)
 
@@ -264,43 +277,75 @@ project (Jerry CXX C ASM)
 
    set(DEFINES_JERRY )
 
-   if("${PLATFORM}" STREQUAL "MCU")
+   if(NOT ${EXTERNAL_BUILD})
-    set(MCU_SCRIPT_GENERATED_HEADER ${MCU_SCRIPT_GENERATED_HEADER}.${TARGET_NAME})
+    add_executable(${TARGET_NAME} ${SOURCE_JERRY_STANDALONE_MAIN})
-    add_custom_command(OUTPUT ${MCU_SCRIPT_GENERATED_HEADER}
-                       COMMAND ${CMAKE_SOURCE_DIR}/tools/generator.sh "${CMAKE_SOURCE_DIR}/${MCU_SCRIPT_FILE}" ${MCU_SCRIPT_GENERATED_HEADER}
-                       WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
-    add_custom_target(mcu_header_with_script_to_run.${TARGET_NAME} DEPENDS ${MCU_SCRIPT_GENERATED_HEADER})
-    set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_MCU_SCRIPT_HEADER="${MCU_SCRIPT_GENERATED_HEADER}")
-   endif()
 
-   add_executable(${TARGET_NAME} ${SOURCE_JERRY_STANDALONE_MAIN})
+    if("${PLATFORM}" STREQUAL "MCU")
-   set_property(TARGET ${TARGET_NAME}
+     set(MCU_SCRIPT_GENERATED_HEADER ${MCU_SCRIPT_GENERATED_HEADER}.${TARGET_NAME})
-                PROPERTY COMPILE_FLAGS "${COMPILE_FLAGS_JERRY} ${CXX_FLAGS_JERRY} ${FLAGS_COMMON_${BUILD_MODE}}")
+     add_custom_command(OUTPUT ${MCU_SCRIPT_GENERATED_HEADER}
-   set_property(TARGET ${TARGET_NAME}
+                        COMMAND ${CMAKE_SOURCE_DIR}/tools/generator.sh "${CMAKE_SOURCE_DIR}/${MCU_SCRIPT_FILE}" ${MCU_SCRIPT_GENERATED_HEADER}
-                PROPERTY LINK_FLAGS "${COMPILE_FLAGS_JERRY} ${CXX_FLAGS_JERRY} ${FLAGS_COMMON_${BUILD_MODE}} ${LINKER_FLAGS_COMMON} ${LINKER_FLAGS_STATIC}")
+                        WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
-   target_compile_definitions(${TARGET_NAME} PRIVATE ${DEFINES_JERRY})
+     add_custom_target(mcu_header_with_script_to_run.${TARGET_NAME} DEPENDS ${MCU_SCRIPT_GENERATED_HEADER})
-   target_include_directories(${TARGET_NAME} PRIVATE ${INCLUDE_CORE_INTERFACE})
+     set(DEFINES_JERRY ${DEFINES_JERRY} JERRY_MCU_SCRIPT_HEADER="${MCU_SCRIPT_GENERATED_HEADER}")
-   target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${INCLUDE_LIBC_INTERFACE})
-   target_link_libraries(${TARGET_NAME} ${PLUGINS_TARGET_NAME} ${CORE_TARGET_NAME} ${LIBC_TARGET_NAME} ${PREFIX_IMPORTED_LIB}libgcc)
-
-   add_cppcheck_target(${TARGET_NAME})
-
-   if("${PLATFORM}" STREQUAL "MCU")
-    add_dependencies(${TARGET_NAME} mcu_header_with_script_to_run.${TARGET_NAME})
-    add_custom_target(${TARGET_NAME}.bin
-                      COMMAND ${CMAKE_OBJCOPY} -Obinary $<TARGET_FILE:${TARGET_NAME}> $<TARGET_FILE:${TARGET_NAME}>.bin
-                      DEPENDS ${TARGET_NAME})
-    add_custom_target(${TARGET_NAME}.flash
-                      COMMAND st-flash write $<TARGET_FILE:${TARGET_NAME}>.bin 0x08000000
-                      DEPENDS ${TARGET_NAME}.bin)
-   endif()
-
-   if("${BUILD_MODE}" STREQUAL "RELEASE")
-    if(${STRIP_RELEASE_BINARY} STREQUAL "ON")
-     add_custom_command(TARGET ${TARGET_NAME}
-                        POST_BUILD
-                        COMMAND ${CMAKE_STRIP} $<TARGET_FILE:${TARGET_NAME}>)
     endif()
+
+    set_property(TARGET ${TARGET_NAME}
+                 PROPERTY COMPILE_FLAGS "${COMPILE_FLAGS_JERRY} ${CXX_FLAGS_JERRY} ${FLAGS_COMMON_${BUILD_MODE}}")
+    set_property(TARGET ${TARGET_NAME}
+                 PROPERTY LINK_FLAGS "${COMPILE_FLAGS_JERRY} ${CXX_FLAGS_JERRY} ${FLAGS_COMMON_${BUILD_MODE}} ${LINKER_FLAGS_COMMON} ${LINKER_FLAGS_STATIC}")
+    target_compile_definitions(${TARGET_NAME} PRIVATE ${DEFINES_JERRY})
+    target_include_directories(${TARGET_NAME} PRIVATE ${INCLUDE_CORE_INTERFACE})
+    target_include_directories(${TARGET_NAME} SYSTEM PRIVATE ${INCLUDE_LIBC_INTERFACE})
+    target_link_libraries(${TARGET_NAME} ${PLUGINS_TARGET_NAME} ${CORE_TARGET_NAME} ${LIBC_TARGET_NAME} ${PREFIX_IMPORTED_LIB}libgcc)
+
+    add_cppcheck_target(${TARGET_NAME})
+
+    if("${PLATFORM}" STREQUAL "MCU")
+     add_dependencies(${TARGET_NAME} mcu_header_with_script_to_run.${TARGET_NAME})
+     add_custom_target(${TARGET_NAME}.bin
+                       COMMAND ${CMAKE_OBJCOPY} -Obinary $<TARGET_FILE:${TARGET_NAME}> $<TARGET_FILE:${TARGET_NAME}>.bin
+                       DEPENDS ${TARGET_NAME})
+     add_custom_target(${TARGET_NAME}.flash
+                       COMMAND st-flash write $<TARGET_FILE:${TARGET_NAME}>.bin 0x08000000
+                       DEPENDS ${TARGET_NAME}.bin)
+    endif()
+
+    if("${BUILD_MODE}" STREQUAL "RELEASE")
+     if(${STRIP_RELEASE_BINARY} STREQUAL "ON")
+      add_custom_command(TARGET ${TARGET_NAME}
+                         POST_BUILD
+                         COMMAND ${CMAKE_STRIP} $<TARGET_FILE:${TARGET_NAME}>)
+     endif()
+    endif()
+   else()
+    set(MAIN_MODULE_TARGET_NAME ${TARGET_NAME}.${PLATFORM_L}.main)
+    add_library(${MAIN_MODULE_TARGET_NAME} ${SOURCE_JERRY_STANDALONE_MAIN})
+    set_property(TARGET ${MAIN_MODULE_TARGET_NAME}
+                 PROPERTY COMPILE_FLAGS "${COMPILE_FLAGS_JERRY} ${CXX_FLAGS_JERRY} ${FLAGS_COMMON_${BUILD_MODE}}")
+    target_compile_definitions(${MAIN_MODULE_TARGET_NAME} PRIVATE ${DEFINES_JERRY})
+    target_include_directories(${MAIN_MODULE_TARGET_NAME} PRIVATE ${INCLUDE_CORE_INTERFACE})
+    target_include_directories(${MAIN_MODULE_TARGET_NAME} SYSTEM PRIVATE ${INCLUDE_LIBC_INTERFACE})
+
+    add_custom_target(${TARGET_NAME} ALL)
+    add_dependencies(${TARGET_NAME} ${MAIN_MODULE_TARGET_NAME} ${PLUGINS_TARGET_NAME} ${CORE_TARGET_NAME})
+
+    add_custom_command(TARGET ${TARGET_NAME}
+                       POST_BUILD
+                       COMMAND mkdir -p ${CMAKE_BINARY_DIR}/${TARGET_NAME}
+                       COMMAND echo
+                       $<TARGET_FILE:${MAIN_MODULE_TARGET_NAME}>
+                       $<TARGET_FILE:${PLUGINS_TARGET_NAME}>
+                       $<TARGET_FILE:${CORE_TARGET_NAME}> > ${CMAKE_BINARY_DIR}/${TARGET_NAME}/list)
+
+    if(NOT ${USE_EXTERNAL_LIBC})
+     if(${PLATFORM} STREQUAL "NUTTX")
+      message(Nuttx build doesn't support Jerry's libc implementation)
+     endif()
+
+     add_dependencies(${TARGET_NAME} ${LIBC_TARGET_NAME})
+    endif()
+
+    add_cppcheck_target(${TARGET_NAME})
    endif()
   endfunction()
 

Makefile

@@ -54,29 +54,41 @@
    STATIC_CHECK := OFF
   endif
 
+# External build configuration
+ EXTERNAL_LIBS_INTERFACE ?= ./third-party/nuttx/include
+ EXTERNAL_C_COMPILER ?= arm-none-eabi-gcc
+ EXTERNAL_CXX_COMPILER ?= arm-none-eabi-g++
+
 export TARGET_DEBUG_MODES = debug
 export TARGET_RELEASE_MODES = release
+
 export TARGET_PC_SYSTEMS = linux
+export TARGET_NUTTX_SYSTEMS = nuttx
 
 export TARGET_PC_MODS = cp cp_minimal mem_stats
+export TARGET_NUTTX_MODS = $(TARGET_PC_MODS)
 
 export TARGET_MCU_MODS = cp cp_minimal
 
 export TARGET_PC_SYSTEMS_MODS = $(TARGET_PC_SYSTEMS) \
                                 $(foreach __MOD,$(TARGET_PC_MODS),$(foreach __SYSTEM,$(TARGET_PC_SYSTEMS),$(__SYSTEM)-$(__MOD)))
+export TARGET_NUTTX_SYSTEMS_MODS = $(TARGET_NUTTX_SYSTEMS) \
+                                   $(foreach __MOD,$(TARGET_NUTTX_MODS),$(foreach __SYSTEM,$(TARGET_NUTTX_SYSTEMS),$(__SYSTEM)-$(__MOD)))
 export TARGET_STM32F3_MODS = $(foreach __MOD,$(TARGET_MCU_MODS),mcu_stm32f3-$(__MOD))
 export TARGET_STM32F4_MODS = $(foreach __MOD,$(TARGET_MCU_MODS),mcu_stm32f4-$(__MOD))
 
 # Target list
 export JERRY_LINUX_TARGETS = $(foreach __MODE,$(TARGET_DEBUG_MODES),$(foreach __SYSTEM,$(TARGET_PC_SYSTEMS_MODS),$(__MODE).$(__SYSTEM))) \
                              $(foreach __MODE,$(TARGET_RELEASE_MODES),$(foreach __SYSTEM,$(TARGET_PC_SYSTEMS_MODS),$(__MODE).$(__SYSTEM)))
+export JERRY_NUTTX_TARGETS = $(foreach __MODE,$(TARGET_DEBUG_MODES),$(foreach __SYSTEM,$(TARGET_NUTTX_SYSTEMS_MODS),$(__MODE).$(__SYSTEM))) \
+                             $(foreach __MODE,$(TARGET_RELEASE_MODES),$(foreach __SYSTEM,$(TARGET_NUTTX_SYSTEMS_MODS),$(__MODE).$(__SYSTEM)))
 
 export JERRY_STM32F3_TARGETS = $(foreach __MODE,$(TARGET_RELEASE_MODES),$(foreach __SYSTEM,$(TARGET_STM32F3_MODS),$(__MODE).$(__SYSTEM)))
 
 export JERRY_STM32F4_TARGETS = $(foreach __MODE,$(TARGET_DEBUG_MODES),$(foreach __SYSTEM,$(TARGET_STM32F4_MODS),$(__MODE).$(__SYSTEM))) \
                                $(foreach __MODE,$(TARGET_RELEASE_MODES),$(foreach __SYSTEM,$(TARGET_STM32F4_MODS),$(__MODE).$(__SYSTEM)))
 
-export JERRY_TARGETS = $(JERRY_LINUX_TARGETS) $(JERRY_STM32F3_TARGETS) $(JERRY_STM32F4_TARGETS) unittests
+export JERRY_TARGETS = $(JERRY_LINUX_TARGETS) $(JERRY_NUTTX_TARGETS) $(JERRY_STM32F3_TARGETS) $(JERRY_STM32F4_TARGETS) unittests
 
 export CHECK_TARGETS = $(foreach __TARGET,$(JERRY_LINUX_TARGETS),$(__TARGET).check)
 export FLASH_TARGETS = $(foreach __TARGET,$(JERRY_STM32F3_TARGETS) $(JERRY_STM32F4_TARGETS),$(__TARGET).flash)
@@ -100,13 +112,15 @@ export SHELL=/bin/bash
 
  # Native
   BUILD_DIRS_NATIVE := $(foreach _OPTIONS_COMBINATION,$(OPTIONS_COMBINATIONS),$(BUILD_DIR_PREFIX)$(_OPTIONS_COMBINATION)/native)
+ # Nuttx
+  BUILD_DIRS_NUTTX := $(foreach _OPTIONS_COMBINATION,$(OPTIONS_COMBINATIONS),$(BUILD_DIR_PREFIX)$(_OPTIONS_COMBINATION)/nuttx)
  # stm32f3
   BUILD_DIRS_STM32F3 := $(foreach _OPTIONS_COMBINATION,$(OPTIONS_COMBINATIONS),$(BUILD_DIR_PREFIX)$(_OPTIONS_COMBINATION)/stm32f3)
  # stm32f4
   BUILD_DIRS_STM32F4 := $(foreach _OPTIONS_COMBINATION,$(OPTIONS_COMBINATIONS),$(BUILD_DIR_PREFIX)$(_OPTIONS_COMBINATION)/stm32f4)
 
  # All together
-  BUILD_DIRS_ALL := $(BUILD_DIRS_NATIVE) $(BUILD_DIRS_STM32F3) $(BUILD_DIRS_STM32F4)
+  BUILD_DIRS_ALL := $(BUILD_DIRS_NATIVE) $(BUILD_DIRS_NUTTX) $(BUILD_DIRS_STM32F3) $(BUILD_DIRS_STM32F4)
 
  # Current
   BUILD_DIR := ./build/obj$(OPTIONS_STRING)
@@ -127,6 +141,24 @@ $(BUILD_DIRS_NATIVE):
           cmake -DENABLE_VALGRIND=$(VALGRIND) -DCMAKE_TOOLCHAIN_FILE=build/configs/toolchain_linux_$$arch.cmake ../../.. &>cmake.log || \
           (echo "CMake run failed. See "`pwd`"/cmake.log for details."; exit 1;)
 
+$(BUILD_DIRS_NUTTX):
+	@ [ "$(EXTERNAL_LIBS_INTERFACE)" != "" ] && [ -x `which $(EXTERNAL_C_COMPILER)` ] && [ -x `which $(EXTERNAL_CXX_COMPILER)` ] || \
+          (echo "Wrong external arguments."; \
+           echo "EXTERNAL_LIBS_INTERFACE='$(EXTERNAL_LIBS_INTERFACE)'"; \
+           echo "EXTERNAL_C_COMPILER='$(EXTERNAL_C_COMPILER)'"; \
+           echo "EXTERNAL_CXX_COMPILER='$(EXTERNAL_CXX_COMPILER)'"; \
+           exit 1;)
+	@ mkdir -p $@ && \
+          cd $@ && \
+          cmake \
+          -DENABLE_VALGRIND=$(VALGRIND) \
+          -DCMAKE_TOOLCHAIN_FILE=build/configs/toolchain_external.cmake \
+          -DEXTERNAL_LIBC_INTERFACE=${EXTERNAL_LIBS_INTERFACE} \
+          -DEXTERNAL_CMAKE_C_COMPILER=${EXTERNAL_C_COMPILER} \
+          -DEXTERNAL_CMAKE_CXX_COMPILER=${EXTERNAL_CXX_COMPILER} \
+          ../../.. &>cmake.log || \
+          (echo "CMake run failed. See "`pwd`"/cmake.log for details."; exit 1;)
+
 $(BUILD_DIRS_STM32F3):
 	@ mkdir -p $@ && \
           cd $@ && \
@@ -164,6 +196,21 @@ $(BUILD_ALL)_native: $(BUILD_DIRS_NATIVE)
 	@ $(MAKE) -C $(BUILD_DIR)/native $(JERRY_LINUX_TARGETS) unittests VERBOSE=1 &>$(OUT_DIR)/$@/make.log || \
           (echo "Build failed. See $(OUT_DIR)/$@/make.log for details."; exit 1;)
 
+$(JERRY_NUTTX_TARGETS): $(BUILD_DIR)/nuttx
+	@ mkdir -p $(OUT_DIR)/$@
+	@ [ "$(STATIC_CHECK)" = "OFF" ] || $(MAKE) -C $(BUILD_DIR)/nuttx VERBOSE=1 cppcheck.$@ &>$(OUT_DIR)/$@/cppcheck.log || \
+          (echo "cppcheck run failed. See $(OUT_DIR)/$@/cppcheck.log for details."; exit 1;)
+	@ $(MAKE) -C $(BUILD_DIR)/nuttx VERBOSE=1 $@ &>$(OUT_DIR)/$@/make.log || \
+          (echo "Build failed. See $(OUT_DIR)/$@/make.log for details."; exit 1;)
+	@ cp `cat $(BUILD_DIR)/nuttx/$@/list` $(OUT_DIR)/$@/
+
+$(BUILD_ALL)_nuttx: $(BUILD_DIRS_NUTTX)
+	@ mkdir -p $(OUT_DIR)/$@
+	@ $(MAKE) -C $(BUILD_DIR)/nuttx plugins-all VERBOSE=1 &>$(OUT_DIR)/$@/make.log || \
+          (echo "Build failed. See $(OUT_DIR)/$@/make.log for details."; exit 1;)
+	@ $(MAKE) -C $(BUILD_DIR)/nuttx $(JERRY_NUTTX_TARGETS) VERBOSE=1 &>$(OUT_DIR)/$@/make.log || \
+          (echo "Build failed. See $(OUT_DIR)/$@/make.log for details."; exit 1;)
+
 $(JERRY_STM32F3_TARGETS): $(BUILD_DIR)/stm32f3
 	@ mkdir -p $(OUT_DIR)/$@
 	@ [ "$(STATIC_CHECK)" = "OFF" ] || $(MAKE) -C $(BUILD_DIR)/stm32f3 VERBOSE=1 cppcheck.$@ &>$(OUT_DIR)/$@/cppcheck.log || \
@@ -200,7 +247,7 @@ $(BUILD_ALL)_stm32f4: $(BUILD_DIRS_STM32F4)
 	@ $(MAKE) -C $(BUILD_DIR)/stm32f4 $(JERRY_STM32F4_TARGETS) VERBOSE=1 &>$(OUT_DIR)/$@/make.log || \
           (echo "Build failed. See $(OUT_DIR)/$@/make.log for details."; exit 1;)
 
-build_all: $(BUILD_ALL)_native $(BUILD_ALL)_stm32f3 $(BUILD_ALL)_stm32f4
+build_all: $(BUILD_ALL)_native $(BUILD_ALL)_nuttx $(BUILD_ALL)_stm32f3 $(BUILD_ALL)_stm32f4
 
 #
 # build - build_all, then run cppcheck and copy output to OUT_DIR

build/configs/toolchain_external.cmake

@@ -0,0 +1,20 @@
+# Copyright 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(CMakeForceCompiler)
+
+set(CMAKE_SYSTEM_NAME NUTTX)
+
+CMAKE_FORCE_C_COMPILER(${EXTERNAL_CMAKE_C_COMPILER} GNU)
+CMAKE_FORCE_CXX_COMPILER(${EXTERNAL_CMAKE_CXX_COMPILER} GNU)

build/static-checkers/add_cppcheck_for_target.cmake

@@ -38,19 +38,28 @@
     set(CPPCHECK_INCLUDES_LIST ${CPPCHECK_INCLUDES_LIST} -I${INCLUDE})
    endforeach()
 
+   set(ADD_CPPCHECK_COMMAND FALSE)
+
    foreach(SOURCE ${TARGET_SOURCES})
     # Add to list if it is C or C++ source
     get_filename_component(SOURCE_EXTENSION ${SOURCE} EXT)
     if("${SOURCE_EXTENSION}" STREQUAL ".c" OR "${SOURCE_EXTENSION}" STREQUAL ".cpp")
      set(CPPCHECK_SOURCES_LIST ${CPPCHECK_SOURCES_LIST} ${SOURCE})
+
+     set(ADD_CPPCHECK_COMMAND true)
     endif()
    endforeach()
 
-  add_custom_target(cppcheck.${TARGET_NAME}
+  if(ADD_CPPCHECK_COMMAND)
-                    COMMAND ${CMAKE_CPPCHECK} -j8 --error-exitcode=1 --language=c++ --std=c++11
+   add_custom_target(cppcheck.${TARGET_NAME}
-                                              --enable=warning,style,performance,portability,information
+                     COMMAND ${CMAKE_CPPCHECK} -j8 --error-exitcode=1 --language=c++ --std=c++11
-                                              ${CPPCHECK_DEFINES_LIST} ${CPPCHECK_SOURCES_LIST} ${CPPCHECK_INCLUDES_LIST}
+                                               --enable=warning,style,performance,portability,information
-                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+                                               ${CPPCHECK_DEFINES_LIST} ${CPPCHECK_SOURCES_LIST} ${CPPCHECK_INCLUDES_LIST}
+                     WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+  else()
+   add_custom_target(cppcheck.${TARGET_NAME})
+  endif()
+
   if(NOT "${TARGET_LIBRARIES}" STREQUAL "TARGET_LIBRARIES-NOTFOUND")
    foreach(LIBRARY ${TARGET_LIBRARIES})
     string(REGEX MATCH "^${PREFIX_IMPORTED_LIB}.*|.*${SUFFIX_THIRD_PARTY_LIB}$" MATCHED ${LIBRARY})

jerry-core/CMakeLists.txt

@@ -74,6 +74,9 @@ project (JerryCore CXX C ASM)
 
  # Platform-specific
   # Linux
+  # Nuttx
+   math(EXPR MEM_HEAP_AREA_SIZE_16K "16 * 1024")
+   set(DEFINES_JERRY_NUTTX CONFIG_MEM_HEAP_AREA_SIZE=${MEM_HEAP_AREA_SIZE_16K})
   # MCU
    math(EXPR MEM_HEAP_AREA_SIZE_16K "16 * 1024")
    set(DEFINES_JERRY_MCU CONFIG_MEM_HEAP_AREA_SIZE=${MEM_HEAP_AREA_SIZE_16K})

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

@@ -139,9 +139,9 @@ ecma_gc_is_object_visited (ecma_object_t *object_p) /**< object */
 {
   JERRY_ASSERT (object_p != NULL);
 
-  bool flag_value = jrt_extract_bit_field (object_p->container,
+  bool flag_value = (bool) jrt_extract_bit_field (object_p->container,
-                                           ECMA_OBJECT_GC_VISITED_POS,
+                                                  ECMA_OBJECT_GC_VISITED_POS,
-                                           ECMA_OBJECT_GC_VISITED_WIDTH);
+                                                  ECMA_OBJECT_GC_VISITED_WIDTH);
 
   return (flag_value != ecma_gc_visited_flip_flag);
 } /* ecma_gc_is_object_visited */

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

@@ -322,7 +322,7 @@ ecma_init_ecma_string_from_lit_index (ecma_string_t *string_p, /**< descriptor t
   JERRY_ASSERT (lit.type == LIT_STR);
 
   string_p->refs = 1;
-  string_p->is_stack_var = is_stack_var;
+  string_p->is_stack_var = (is_stack_var != 0);
   string_p->container = ECMA_STRING_CONTAINER_LIT_TABLE;
   string_p->hash = lit.data.lp.hash;
 
@@ -345,7 +345,7 @@ ecma_init_ecma_string_from_magic_string_id (ecma_string_t *string_p, /**< descri
 #endif /* !JERRY_NDEBUG */
 
   string_p->refs = 1;
-  string_p->is_stack_var = is_stack_var;
+  string_p->is_stack_var = (is_stack_var != 0);
   string_p->container = ECMA_STRING_CONTAINER_MAGIC_STRING;
   string_p->hash = ecma_chars_buffer_calc_hash_last_chars (ecma_get_magic_string_zt (magic_string_id),
                                                            ecma_magic_string_lengths [magic_string_id]);

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

@@ -187,9 +187,9 @@ ecma_is_lexical_environment (const ecma_object_t *object_p) /**< object or lexic
 {
   JERRY_ASSERT (object_p != NULL);
 
-  return jrt_extract_bit_field (object_p->container,
+  return (bool) jrt_extract_bit_field (object_p->container,
-                                ECMA_OBJECT_IS_LEXICAL_ENVIRONMENT_POS,
+                                       ECMA_OBJECT_IS_LEXICAL_ENVIRONMENT_POS,
-                                ECMA_OBJECT_IS_LEXICAL_ENVIRONMENT_WIDTH);
+                                       ECMA_OBJECT_IS_LEXICAL_ENVIRONMENT_WIDTH);
 } /* ecma_is_lexical_environment */
 
 /**
@@ -201,9 +201,9 @@ ecma_get_object_extensible (const ecma_object_t *object_p) /**< object */
   JERRY_ASSERT (object_p != NULL);
   JERRY_ASSERT (!ecma_is_lexical_environment (object_p));
 
-  return jrt_extract_bit_field (object_p->container,
+  return (bool) jrt_extract_bit_field (object_p->container,
-                                ECMA_OBJECT_OBJ_EXTENSIBLE_POS,
+                                       ECMA_OBJECT_OBJ_EXTENSIBLE_POS,
-                                ECMA_OBJECT_OBJ_EXTENSIBLE_WIDTH);
+                                       ECMA_OBJECT_OBJ_EXTENSIBLE_WIDTH);
 } /* ecma_get_object_extensible */
 
 /**
@@ -1170,11 +1170,11 @@ ecma_set_property_lcached (ecma_property_t *prop_p, /**< property */
 
   if (prop_p->type == ECMA_PROPERTY_NAMEDDATA)
   {
-    prop_p->u.named_data_property.is_lcached = is_lcached;
+    prop_p->u.named_data_property.is_lcached = (is_lcached != 0);
   }
   else
   {
-    prop_p->u.named_accessor_property.is_lcached = is_lcached;
+    prop_p->u.named_accessor_property.is_lcached = (is_lcached != 0);
   }
 } /* ecma_set_property_lcached */
 

jerry-core/ecma/operations/ecma-reference.cpp

@@ -101,7 +101,7 @@ ecma_make_reference (const ecma_value_t& base, /**< base value */
 
   ecma_reference_t ref;
   ref.base = ecma_copy_value (base, true);
-  ref.is_strict = is_strict;
+  ref.is_strict = (is_strict != 0);
 
   ECMA_SET_POINTER (ref.referenced_name_cp, name_p);
 

jerry-core/jerry-extension.h

@@ -16,6 +16,7 @@
 #ifndef JERRY_EXTENSION_H
 #define JERRY_EXTENSION_H
 
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 

main-nuttx.cpp

@@ -0,0 +1,202 @@
+/* Copyright 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 <stdio.h>
+#include <string.h>
+
+#include "jerry.h"
+
+/**
+ * The module interface routine
+ */
+extern "C" int jerry_main (int argc, char *argv[]);
+
+/**
+ * Maximum command line arguments number
+ */
+#define JERRY_MAX_COMMAND_LINE_ARGS (64)
+
+/**
+ * Maximum size of source code buffer
+ */
+#define JERRY_SOURCE_BUFFER_SIZE (1024)
+
+/**
+ * Standalone Jerry exit codes
+ */
+#define JERRY_STANDALONE_EXIT_CODE_OK   (0)
+#define JERRY_STANDALONE_EXIT_CODE_FAIL (1)
+
+static uint8_t source_buffer[ JERRY_SOURCE_BUFFER_SIZE ];
+
+static const char*
+read_sources (const char *script_file_names[],
+              int files_count,
+              size_t *out_source_size_p)
+{
+  int i;
+  uint8_t *source_buffer_tail = source_buffer;
+
+  FILE *file = NULL;
+
+  for (i = 0; i < files_count; i++)
+  {
+    const char *script_file_name = script_file_names[i];
+
+    file = fopen (script_file_name, "r");
+
+    if (file == NULL)
+    {
+      break;
+    }
+
+    int fseek_status = fseek (file, 0, SEEK_END);
+
+    if (fseek_status != 0)
+    {
+      break;
+    }
+
+    long script_len = ftell (file);
+
+    if (script_len < 0)
+    {
+      break;
+    }
+
+    rewind (file);
+
+    const size_t current_source_size = (size_t)script_len;
+
+    if (source_buffer_tail + current_source_size >= source_buffer + sizeof (source_buffer))
+    {
+      break;
+    }
+
+    size_t bytes_read = fread (source_buffer_tail, 1, current_source_size, file);
+    if (bytes_read < current_source_size)
+    {
+      break;
+    }
+
+    fclose (file);
+    file = NULL;
+
+    source_buffer_tail += current_source_size;
+  }
+
+  if (file != NULL)
+  {
+    fclose (file);
+  }
+
+  if (i < files_count)
+  {
+    printf ("Failed to read script N%d\n", i + 1);
+
+    return NULL;
+  }
+  else
+  {
+    const size_t source_size = (size_t) (source_buffer_tail - source_buffer);
+
+    *out_source_size_p = source_size;
+
+    return (const char*)source_buffer;
+  }
+}
+
+int jerry_main (int argc, char *argv[])
+{
+  if (argc >= JERRY_MAX_COMMAND_LINE_ARGS)
+  {
+    printf ("Too many command line arguments. Current maximum is %d (JERRY_MAX_COMMAND_LINE_ARGS)\n", argc);
+
+    return JERRY_STANDALONE_EXIT_CODE_FAIL;
+  }
+
+  const char *file_names[JERRY_MAX_COMMAND_LINE_ARGS];
+  int i;
+  int files_counter = 0;
+
+  for (i = 0; i < argc; i++)
+  {
+    printf ("PARAM %d : [%s]\n", i, argv[i]);
+  }
+
+  jerry_flag_t flags = JERRY_FLAG_EMPTY;
+
+  for (i = 1; i < argc; i++)
+  {
+    if (!strcmp ("-v", argv[i]))
+    {
+      printf ("Build date: \t%s\n", jerry_build_date);
+      printf ("Commit hash:\t%s\n", jerry_commit_hash);
+      printf ("Branch name:\t%s\n", jerry_branch_name);
+    }
+    else if (!strcmp ("--mem-stats", argv[i]))
+    {
+#ifdef MEM_STATS
+      flags |= JERRY_FLAG_MEM_STATS;
+#else /* MEM_STATS */
+      printf ("Ignoring --mem-stats because of '!MEM_STATS' build configuration.\n");
+#endif /* !MEM_STATS */
+    }
+    else if (!strcmp ("--parse-only", argv[i]))
+    {
+      flags |= JERRY_FLAG_PARSE_ONLY;
+    }
+    else if (!strcmp ("--show-opcodes", argv[i]))
+    {
+      flags |= JERRY_FLAG_SHOW_OPCODES;
+    }
+    else
+    {
+      file_names[files_counter++] = argv[i];
+    }
+  }
+
+  if (files_counter == 0)
+  {
+    printf ("Jerry: file count 0\n");
+    return JERRY_STANDALONE_EXIT_CODE_OK;
+  }
+  else
+  {
+    size_t source_size;
+    const char *source_p = read_sources (file_names, files_counter, &source_size);
+
+    if (source_p == NULL)
+    {
+      printf ("Err: JERRY_STANDALONE_EXIT_CODE_FAIL\n");
+      return JERRY_STANDALONE_EXIT_CODE_FAIL;
+    }
+    else
+    {
+      printf ("Source:\n------------\n%s\n------------\n", source_p);
+
+      jerry_completion_code_t ret_code = jerry_run_simple (source_p, source_size, flags);
+
+      if (ret_code == JERRY_COMPLETION_CODE_OK)
+      {
+        return JERRY_STANDALONE_EXIT_CODE_OK;
+      }
+      else
+      {
+        return JERRY_STANDALONE_EXIT_CODE_FAIL;
+      }
+    }
+  }
+}

plugins/CMakeLists.txt

@@ -33,6 +33,8 @@ project (Jerry_Plugins CXX ASM)
     set(DEFINES_PLUGINS_MCU_STM32F3 __TARGET_MCU __TARGET_MCU_STM32F3)
    # stm32f4
     set(DEFINES_PLUGINS_MCU_STM32F4 __TARGET_MCU __TARGET_MCU_STM32F4)
+  # Nuttx
+   set(DEFINES_PLUGINS_NUTTX __TARGET_NUTTX)
 
 # Include directories
  set(INCLUDE_PLUGINS
@@ -58,10 +60,14 @@ project (Jerry_Plugins CXX ASM)
         ${CMAKE_SOURCE_DIR}/third-party/STM32F4-Discovery_FW_V1.1.0/Libraries/CMSIS/Include
         ${CMAKE_SOURCE_DIR}/third-party/STM32F4-Discovery_FW_V1.1.0)
 
+   # Nuttx
+    set(INCLUDE_THIRD_PARTY_NUTTX
+        ${EXTERNAL_LIBC_INTERFACE})
+
 # Sources
  file(GLOB SOURCE_PLUGINS
-      lib-device-stm/*.cpp
+      io/*.cpp
-      io/*.cpp)
+      lib-device-stm/*.cpp)
 
  # Third-party
   # Platform-specific

plugins/lib-device-stm/actuators.cpp

@@ -20,14 +20,14 @@
 #include "actuators.h"
 #include "common-io.h"
 
-#ifdef __TARGET_HOST
+#if defined (__TARGET_HOST) || defined (__TARGET_NUTTX)
 /**
  * Host stub for LEDToggle operation
  */
 void
 led_toggle (uint32_t led_id) /**< index of LED */
 {
-  printf ("led_toggle: %d\n", led_id);
+  printf ("led_toggle: %lu\n", led_id);
 }
 
 /**
@@ -36,7 +36,7 @@ led_toggle (uint32_t led_id) /**< index of LED */
 void
 led_on (uint32_t led_id) /**< index of LED */
 {
-  printf ("led_on: %d\n", led_id);
+  printf ("led_on: %lu\n", led_id);
 }
 
 /**
@@ -45,7 +45,7 @@ led_on (uint32_t led_id) /**< index of LED */
 void
 led_off (uint32_t led_id) /**< index of LED */
 {
-  printf ("led_off: %d\n", led_id);
+  printf ("led_off: %lu\n", led_id);
 }
 
 /**
@@ -54,11 +54,11 @@ led_off (uint32_t led_id) /**< index of LED */
 void
 led_blink_once (uint32_t led_id) /**< index of LED */
 {
-  printf ("led_blink_once: %d\n", led_id);
+  printf ("led_blink_once: %lu\n", led_id);
 }
-#else /* !__TARGET_HOST */
+#else /* !__TARGET_HOST && !__TARGET_NUTTX */
 #ifndef __TARGET_MCU
-# error "!__TARGET_HOST && !__TARGET_MCU"
+# error "!__TARGET_HOST && && !__TARGET_NUTTX !__TARGET_MCU"
 #endif /* !__TARGET_MCU */
 
 #include "mcu-headers.h"
@@ -230,4 +230,4 @@ led_blink_once (uint32_t led_id) /**< index of LED */
   led_off (led_id);
 } /* led_blink_once */
 
-#endif /* !__TARGET_HOST && __TARGET_MCU */
+#endif /* !__TARGET_HOST && !__TARGET_NUTTX && __TARGET_MCU */

plugins/lib-device-stm/common-io.cpp

@@ -54,16 +54,16 @@ analog_write (uint32_t arg1, uint32_t arg2)
   (void) arg2;
 }
 
-#ifdef __TARGET_HOST
+#if defined (__TARGET_HOST) || defined (__TARGET_NUTTX)
 void
 wait_ms (uint32_t time_ms)
 {
-  printf ("wait_ms: %d\n", time_ms);
+  printf ("wait_ms: %lu\n", time_ms);
 }
 #else /* !__TARGET_HOST */
 
 #ifndef __TARGET_MCU
-# error "!__TARGET_HOST && !__TARGET_MCU"
+# error "!__TARGET_HOST && && !__TARGET_NUTTX !__TARGET_MCU"
 #endif /* !__TARGET_MCU */
 
 static __IO uint32_t sys_tick_counter;
@@ -162,4 +162,4 @@ initialize_timer ()
   TIM_TimeBaseInit (TIM2, &timerInitStructure);
   TIM_Cmd (TIM2, ENABLE);
 }
-#endif /* !__TARGET_HOST && __TARGET_MCU */
+#endif /* !__TARGET_HOST && !__TARGET_NUTTX && __TARGET_MCU */