YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Separate targets into os and baremetal-sdk parts (#4842)

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Roland Takacs roland.takacs@h-lab.eu
This commit is contained in:
Roland Takacs
2021-12-06 11:02:52 +01:00
committed by GitHub
parent 9860d66a56
commit af297bc578
110 changed files with 119 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files
targets/os/zephyr/CMakeLists.txt
+45
View File
@@ -0,0 +1,45 @@
# Copyright JS Foundation and other contributors, http://js.foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
cmake_minimum_required(VERSION 3.20.0)
find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(NONE)
set(JERRY_BASE ${CMAKE_SOURCE_DIR}/../../..)
# Build JerryScript
execute_process(COMMAND ${JERRY_BASE}/tools/build.py
--clean
--lto=OFF
--jerry-cmdline=OFF
--jerry-math=ON
--amalgam=ON
--mem-heap=70
--profile=es.next
--compile-flag=--sysroot=${ZEPHYR_BASE}
--toolchain=${JERRY_BASE}/cmake/toolchain_mcu_stm32f4.cmake)
# Define library targets
add_library(jerry-core STATIC IMPORTED)
add_library(jerry-ext STATIC IMPORTED)
# Define include directories and archives
set_target_properties(jerry-core PROPERTIES IMPORTED_LOCATION ${JERRY_BASE}/build/lib/libjerry-core.a)
set_target_properties(jerry-core PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${JERRY_BASE}/jerry-core/include)
set_target_properties(jerry-ext PROPERTIES IMPORTED_LOCATION ${JERRY_BASE}/build/lib/libjerry-ext.a)
set_target_properties(jerry-ext PROPERTIES INTERFACE_INCLUDE_DIRECTORIES ${JERRY_BASE}/jerry-ext/include)
target_sources(app PRIVATE src/main-zephyr.c src/getline-zephyr.c src/jerry-port.c src/jerry-module.c)
target_link_libraries(app PUBLIC jerry-core jerry-ext)
targets/os/zephyr/Makefile.travis
+63
View File
@@ -0,0 +1,63 @@
# Copyright JS Foundation and other contributors, http://js.foundation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Default target for running the build test outside the Travis CI environment.
all:
$(MAKE) install
$(MAKE) script
## Targets for installing build dependencies of the Zephyr JerryScript target.
# Install tools via apt.
install-apt-get-deps:
sudo apt-get install -q -y gperf dfu-util device-tree-compiler gcc-arm-none-eabi
# Install Zephyr SDK.
install-zephyr-toolchain:
wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.13.2/zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run -O ../zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run
sh ../zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run -- -y -d $(CURDIR)/../zephyr-toolchain-0.13.2
# Fetch Zephyr Project repository and install python dependencies.
install-zephyr:
git clone https://github.com/zephyrproject-rtos/zephyr.git ../zephyr -b v2.7.0
pip3 install -U pip
pip3 install -U setuptools
pip3 install -r ../zephyr/scripts/requirements.txt
# Install recent CMake
install-cmake:
pip install cmake
cmake --version
# Perform all the necessary (JerryScript-independent) installation steps.
install-noapt: install-zephyr-toolchain install-zephyr install-cmake
install: install-apt-get-deps install-noapt
## Targets for building Zephyr with JerryScript.
# Initialize west meta-tool
init-west:
west init -l $(CURDIR)/../zephyr
west update hal_stm32 cmsis
west zephyr-export
# Build the firmware (Zephyr with JerryScript).
SHELL=bash
script: init-west
export ZEPHYR_TOOLCHAIN_VARIANT=zephyr && \
export ZEPHYR_SDK_INSTALL_DIR=$(CURDIR)/../zephyr-toolchain-0.13.2 && \
west build -d $(CURDIR)/../build -p auto -b stm32f4_disco targets/os/zephyr/ -- -G'Unix Makefiles'
targets/os/zephyr/README.md
+130
View File
@@ -0,0 +1,130 @@
### About
This folder contains files to run JerryScript on
[STM32F4-Discovery board](https://www.st.com/en/evaluation-tools/stm32f4discovery.html) with
[Zephyr](https://zephyrproject.org/).
The document had been validated on Ubuntu 20.04 operating system.
#### 1. Setup the build environment
Clone the necessary projects into a `jerry-zephyr` directory.
The latest tested working version of Zephyr is `v2.7.0`.
```sh
mkdir jerry-zephyr && cd jerry-zephyr
git clone https://github.com/jerryscript-project/jerryscript.git
git clone https://github.com/zephyrproject-rtos/zephyr -b v2.7.0
# Zephyr requires its toolchain.
wget https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.13.2/zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run
```
The following directory structure has been created:
```
jerry-zephyr
+ jerryscript
| + targets
| + os
| + zephyr
+ zephyr
+ zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run
```
#### 2. Install dependencies of the projects
```sh
# Assuming you are in jerry-zephyr folder.
jerryscript/tools/apt-get-install-deps.sh
# Tool dependencies of Zephyr.
sudo apt install --no-install-recommends \
git cmake ninja-build gperf ccache dfu-util device-tree-compiler \
python3-dev python3-pip python3-setuptools python3-tk python3-wheel \
xz-utils file make gcc gcc-multilib g++-multilib libsdl2-dev
# Install Python dependencies of Zephyr.
pip3 install --user -r zephyr/scripts/requirements.txt
# Install Zephyr toolchain.
chmod +x zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run
./zephyr-toolchain-arm-0.13.2-linux-x86_64-setup.run -- -y -d ${PWD}/zephyr-toolchain-0.13.2
```
Note: CMake 3.20 is required. If the installed CMake is older, upgrade it for example [this way](https://apt.kitware.com/).
#### 3. Initialize west meta-tool for Zephyr
```
# Assuming you are in jerry-zephyr folder.
west init -l zephyr
west update hal_stm32 cmsis
west zephyr-export
```
#### 4. Build Zephyr (with JerryScript)
```
# Assuming you are in jerry-zephyr folder.
west build -p auto -b stm32f4_disco jerryscript/targets/os/zephyr/
```
The created binary is a `zephyr.elf` named file located in `jerry-zephyr/build/zephyr/bin/` folder.
#### 5. Flash
Install `udev` rules which allows to flash STM32F4-Discovery as a regular user:
```
# Assuming you are in jerry-zephyr folder.
sudo cp zephyr-toolchain-0.13.2/sysroots/x86_64-pokysdk-linux/usr/share/openocd/contrib/60-openocd.rules /etc/udev/rules.d
sudo udevadm control --reload
```
Connect Mini-USB for charging and flasing the device.
```
# Assuming you are in jerry-zephyr folder.
west flash
```
#### 6. Connect to the device
Use `USB To TTL Serial Converter` for serial communication. STM32F4-Discovery pins are mapped by Zephyr as follows:
```
STM32f4-Discovery PA2 pin is configured for TX.
STM32f4-Discovery PA3 pin is configured for RX.
```
* Connect `STM32f4-Discovery` **PA2** pin to **RX** pin of `USB To TTL Serial Converter`
* Connect `STM32f4-Discovery` **PA3** pin to **TX** pin of `USB To TTL Serial Converter`
* Connect `STM32f4-Discovery` **GND** pin to **GND** pin of `USB To TTL Serial Converter`
The device should be visible as `/dev/ttyUSB0`. Use `minicom` communication program with `115200`.
* In `minicom`, set `Add Carriage Ret` to `off` in by `CTRL-A -> Z -> U` key combinations.
* In `minicom`, set `Hardware Flow Control` to `no` by `CTRL-A -> Z -> O -> Serial port setup -> F` key combinations.
```sh
sudo minicom --device=/dev/ttyUSB0 --baud=115200
```
Press `RESET` on the board to get the initial message with JerryScript command prompt:
```
*** Booting Zephyr OS build v2.7.99-1786-ga08b65ef42db ***
JerryScript build: Nov 25 2021 14:17:17
JerryScript API 3.0.0
Zephyr version 2.7.99
js>
```
Run the following JavaScript example:
```
js> var test = 0; for (t = 100; t < 1000; t++) test += t; print ('Hello World! ' + test);
Hello World! 494550
undefined
```
targets/os/zephyr/prj.conf
+6
View File
@@ -0,0 +1,6 @@
CONFIG_BUILD_OUTPUT_BIN=y
CONFIG_STDOUT_CONSOLE=y
CONFIG_NEWLIB_LIBC=y
CONFIG_FPU=y
CONFIG_MAIN_STACK_SIZE=2048
CONFIG_CONSOLE_HANDLER=y
targets/os/zephyr/src/getline-zephyr.c
+58
View File
@@ -0,0 +1,58 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <zephyr.h>
#include <drivers/uart.h>
#include <drivers/console/console.h>
#include <drivers/console/uart_console.h>
#include "getline-zephyr.h"
/* While app processes one input line, Zephyr will have another line
buffer to accumulate more console input. */
static struct console_input line_bufs[2];
static struct k_fifo free_queue;
static struct k_fifo used_queue;
char *zephyr_getline(void)
{
static struct console_input *cmd;
/* Recycle cmd buffer returned previous time */
if (cmd != NULL)
{
k_fifo_put(&free_queue, cmd);
}
cmd = k_fifo_get(&used_queue, K_FOREVER);
return cmd->line;
}
void zephyr_getline_init(void)
{
int i;
k_fifo_init(&used_queue);
k_fifo_init(&free_queue);
for (i = 0; i < sizeof(line_bufs) / sizeof(*line_bufs); i++)
{
k_fifo_put(&free_queue, &line_bufs[i]);
}
/* Zephyr UART handler takes an empty buffer from free_queue,
stores UART input in it until EOL, and then puts it into
used_queue. */
uart_register_input(&free_queue, &used_queue, NULL);
}
targets/os/zephyr/src/getline-zephyr.h
+17
View File
@@ -0,0 +1,17 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
void zephyr_getline_init(void);
char *zephyr_getline(void);
targets/os/zephyr/src/jerry-module.c
+293
View File
@@ -0,0 +1,293 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "jerryscript-port.h"
#include "jerryscript.h"
/**
* Computes the end of the directory part of a path.
*
* @return end of the directory part of a path.
*/
static size_t
jerry_port_get_directory_end (const jerry_char_t *path_p) /**< path */
{
const jerry_char_t *end_p = path_p + strlen ((const char *) path_p);
while (end_p > path_p)
{
if (end_p[-1] == '/')
{
return (size_t) (end_p - path_p);
}
end_p--;
}
return 0;
} /* jerry_port_get_directory_end */
/**
* Normalize a file path.
*
* @return a newly allocated buffer with the normalized path if the operation is successful,
* NULL otherwise
*/
static jerry_char_t *
jerry_port_normalize_path (const jerry_char_t *in_path_p, /**< path to the referenced module */
size_t in_path_length, /**< length of the path */
const jerry_char_t *base_path_p, /**< base path */
size_t base_path_length) /**< length of the base path */
{
char *path_p;
if (base_path_length > 0)
{
path_p = (char *) malloc (base_path_length + in_path_length + 1);
if (path_p == NULL)
{
return NULL;
}
memcpy (path_p, base_path_p, base_path_length);
memcpy (path_p + base_path_length, in_path_p, in_path_length);
path_p[base_path_length + in_path_length] = '\0';
}
else
{
path_p = (char *) malloc (in_path_length + 1);
if (path_p == NULL)
{
return NULL;
}
memcpy (path_p, in_path_p, in_path_length);
path_p[in_path_length] = '\0';
}
return (jerry_char_t *) path_p;
} /* jerry_port_normalize_path */
/**
* A module descriptor.
*/
typedef struct jerry_port_module_t
{
struct jerry_port_module_t *next_p; /**< next_module */
jerry_char_t *path_p; /**< path to the module */
size_t base_path_length; /**< base path length for relative difference */
jerry_value_t realm; /**< the realm of the module */
jerry_value_t module; /**< the module itself */
} jerry_port_module_t;
/**
* Native info descriptor for modules.
*/
static const jerry_object_native_info_t jerry_port_module_native_info = {
.free_cb = NULL,
};
/**
* Default module manager.
*/
typedef struct
{
jerry_port_module_t *module_head_p; /**< first module */
} jerry_port_module_manager_t;
/**
* Release known modules.
*/
static void
jerry_port_module_free (jerry_port_module_manager_t *manager_p, /**< module manager */
const jerry_value_t realm) /**< if this argument is object, release only those modules,
* which realm value is equal to this argument. */
{
jerry_port_module_t *module_p = manager_p->module_head_p;
bool release_all = !jerry_value_is_object (realm);
jerry_port_module_t *prev_p = NULL;
while (module_p != NULL)
{
jerry_port_module_t *next_p = module_p->next_p;
if (release_all || module_p->realm == realm)
{
free (module_p->path_p);
jerry_value_free (module_p->realm);
jerry_value_free (module_p->module);
free (module_p);
if (prev_p == NULL)
{
manager_p->module_head_p = next_p;
}
else
{
prev_p->next_p = next_p;
}
}
else
{
prev_p = module_p;
}
module_p = next_p;
}
} /* jerry_port_module_free */
/**
* Initialize the default module manager.
*/
static void
jerry_port_module_manager_init (void *user_data_p)
{
((jerry_port_module_manager_t *) user_data_p)->module_head_p = NULL;
} /* jerry_port_module_manager_init */
/**
* Deinitialize the default module manager.
*/
static void
jerry_port_module_manager_deinit (void *user_data_p) /**< context pointer to deinitialize */
{
jerry_value_t undef = jerry_undefined ();
jerry_port_module_free ((jerry_port_module_manager_t *) user_data_p, undef);
jerry_value_free (undef);
} /* jerry_port_module_manager_deinit */
/**
* Declare the context data manager for modules.
*/
static const jerry_context_data_manager_t jerry_port_module_manager = { .init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed =
sizeof (jerry_port_module_manager_t) };
/**
* Default module resolver.
*
* @return a module object if resolving is successful, an error otherwise
*/
jerry_value_t
jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier string */
const jerry_value_t referrer, /**< parent module */
void *user_p) /**< user data */
{
(void) user_p;
jerry_port_module_t *module_p = jerry_object_get_native_ptr (referrer, &jerry_port_module_native_info);
const jerry_char_t *base_path_p = NULL;
size_t base_path_length = 0;
if (module_p != NULL)
{
base_path_p = module_p->path_p;
base_path_length = module_p->base_path_length;
}
jerry_size_t in_path_length = jerry_string_size (specifier, JERRY_ENCODING_UTF8);
jerry_char_t *in_path_p = (jerry_char_t *) malloc (in_path_length + 1);
jerry_string_to_buffer (specifier, JERRY_ENCODING_UTF8, in_path_p, in_path_length);
in_path_p[in_path_length] = '\0';
jerry_char_t *path_p = jerry_port_normalize_path (in_path_p, in_path_length, base_path_p, base_path_length);
if (path_p == NULL)
{
return jerry_throw_sz (JERRY_ERROR_COMMON, "Out of memory");
}
jerry_value_t realm = jerry_current_realm ();
jerry_port_module_manager_t *manager_p;
manager_p = (jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager);
module_p = manager_p->module_head_p;
while (module_p != NULL)
{
if (module_p->realm == realm && strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
{
free (path_p);
free (in_path_p);
jerry_value_free (realm);
return jerry_value_copy (module_p->module);
}
module_p = module_p->next_p;
}
size_t source_size;
uint8_t *source_p = jerry_port_read_source ((const char *) path_p, &source_size);
if (source_p == NULL)
{
free (path_p);
free (in_path_p);
jerry_value_free (realm);
return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Module file not found");
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string ((const jerry_char_t *) in_path_p, in_path_length, JERRY_ENCODING_UTF8);
jerry_value_t ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_value_free (parse_options.source_name);
jerry_port_release_source (source_p);
free (in_path_p);
if (jerry_value_is_exception (ret_value))
{
free (path_p);
jerry_value_free (realm);
return ret_value;
}
module_p = (jerry_port_module_t *) malloc (sizeof (jerry_port_module_t));
module_p->next_p = manager_p->module_head_p;
module_p->path_p = path_p;
module_p->base_path_length = jerry_port_get_directory_end (module_p->path_p);
module_p->realm = realm;
module_p->module = jerry_value_copy (ret_value);
jerry_object_set_native_ptr (ret_value, &jerry_port_module_native_info, module_p);
manager_p->module_head_p = module_p;
return ret_value;
} /* jerry_port_module_resolve */
/**
* Release known modules.
*/
void
jerry_port_module_release (const jerry_value_t realm) /**< if this argument is object, release only those modules,
* which realm value is equal to this argument. */
{
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager), realm);
} /* jerry_port_module_release */
targets/os/zephyr/src/jerry-port.c
+192
View File
@@ -0,0 +1,192 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <zephyr.h>
#include <stdarg.h>
#include <stdlib.h>
#include "jerryscript-port.h"
/**
* JerryScript log level
*/
static jerry_log_level_t jerry_log_level = JERRY_LOG_LEVEL_ERROR;
/**
* Sets log level.
*/
void set_log_level (jerry_log_level_t level)
{
jerry_log_level = level;
} /* set_log_level */
/**
* Aborts the program.
*/
void jerry_port_fatal (jerry_fatal_code_t code)
{
exit (1);
} /* jerry_port_fatal */
/**
* Provide log message implementation for the engine.
*/
void
jerry_port_log (jerry_log_level_t level, /**< log level */
const char *format, /**< format string */
...) /**< parameters */
{
if (level <= jerry_log_level)
{
va_list args;
va_start (args, format);
vfprintf (stderr, format, args);
va_end (args);
}
} /* jerry_port_log */
/**
* Determines the size of the given file.
* @return size of the file
*/
static size_t
jerry_port_get_file_size (FILE *file_p) /**< opened file */
{
fseek (file_p, 0, SEEK_END);
long size = ftell (file_p);
fseek (file_p, 0, SEEK_SET);
return (size_t) size;
} /* jerry_port_get_file_size */
/**
* Opens file with the given path and reads its source.
* @return the source of the file
*/
uint8_t *
jerry_port_read_source (const char *file_name_p, /**< file name */
size_t *out_size_p) /**< [out] read bytes */
{
FILE *file_p = fopen (file_name_p, "rb");
if (file_p == NULL)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: failed to open file: %s\n", file_name_p);
return NULL;
}
size_t file_size = jerry_port_get_file_size (file_p);
uint8_t *buffer_p = (uint8_t *) malloc (file_size);
if (buffer_p == NULL)
{
fclose (file_p);
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: failed to allocate memory for module");
return NULL;
}
size_t bytes_read = fread (buffer_p, 1u, file_size, file_p);
if (!bytes_read)
{
fclose (file_p);
free (buffer_p);
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: failed to read file: %s\n", file_name_p);
return NULL;
}
fclose (file_p);
*out_size_p = bytes_read;
return buffer_p;
} /* jerry_port_read_source */
/**
* Release the previously opened file's content.
*/
void
jerry_port_release_source (uint8_t *buffer_p) /**< buffer to free */
{
free (buffer_p);
} /* jerry_port_release_source */
/**
* Dummy function to get the time zone adjustment.
*
* @return 0
*/
double
jerry_port_get_local_time_zone_adjustment (double unix_ms, bool is_utc)
{
/* We live in UTC. */
return 0;
} /* jerry_port_get_local_time_zone_adjustment */
/**
* Dummy function to get the current time.
*
* @return 0
*/
double
jerry_port_get_current_time (void)
{
int64_t ms = k_uptime_get();
return (double) ms;
} /* jerry_port_get_current_time */
/**
* Provide the implementation of jerry_port_print_char.
* Uses 'printf' to print a single character to standard output.
*/
void
jerry_port_print_char (char c) /**< the character to print */
{
printf ("%c", c);
} /* jerry_port_print_char */
/**
* Provide implementation of jerry_port_sleep.
*/
void jerry_port_sleep (uint32_t sleep_time) /**< milliseconds to sleep */
{
k_usleep ((useconds_t) sleep_time * 1000);
} /* jerry_port_sleep */
/**
* Pointer to the current context.
*/
static jerry_context_t *current_context_p = NULL;
/**
* Set the current_context_p as the passed pointer.
*/
void
jerry_port_default_set_current_context (jerry_context_t *context_p) /**< points to the created context */
{
current_context_p = context_p;
} /* jerry_port_default_set_current_context */
/**
* Get the current context.
*
* @return the pointer to the current context
*/
jerry_context_t *
jerry_port_get_current_context (void)
{
return current_context_p;
} /* jerry_port_get_current_context */
targets/os/zephyr/src/main-zephyr.c
+120
View File
@@ -0,0 +1,120 @@
/* Copyright JS Foundation and other contributors, http://js.foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <zephyr.h>
#include "jerryscript-port.h"
#include "jerryscript.h"
#include "getline-zephyr.h"
#include "jerryscript-ext/handler.h"
#include <sys/printk.h>
static jerry_value_t print_function;
/**
* Register a JavaScript function in the global object.
*/
static void
register_js_function (const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t result_val = jerryx_handler_register_global (name_p, handler_p);
if (jerry_value_is_exception (result_val))
{
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
}
jerry_value_free (result_val);
} /* register_js_function */
static int
shell_cmd_handler (char *source_buffer)
{
jerry_value_t ret_val;
ret_val = jerry_eval ((jerry_char_t *) source_buffer, strlen (source_buffer), JERRY_PARSE_NO_OPTS);
if (jerry_value_is_exception (ret_val))
{
/* User-friendly error messages require at least "cp" JerryScript
profile. Include a message prefix in case "cp_minimal" profile
is used. */
printf ("Error executing statement: ");
/* Clear error flag, otherwise print call below won't produce any
output. */
ret_val = jerry_exception_value (ret_val, true);
}
if (!jerry_value_is_exception (print_function))
{
jerry_value_t ret_val_print = jerry_call (print_function, jerry_undefined (), &ret_val, 1);
jerry_value_free (ret_val_print);
}
jerry_value_free (ret_val);
return 0;
} /* shell_cmd_handler */
void
main (void)
{
union
{
double d;
unsigned u;
} now = { .d = jerry_port_get_current_time () };
srand (now.u);
uint32_t zephyr_ver = sys_kernel_version_get ();
printf ("JerryScript build: " __DATE__ " " __TIME__ "\n");
printf ("JerryScript API %d.%d.%d\n", JERRY_API_MAJOR_VERSION, JERRY_API_MINOR_VERSION, JERRY_API_PATCH_VERSION);
printf ("Zephyr version %d.%d.%d\n",
(int) SYS_KERNEL_VER_MAJOR (zephyr_ver),
(int) SYS_KERNEL_VER_MINOR (zephyr_ver),
(int) SYS_KERNEL_VER_PATCHLEVEL (zephyr_ver));
zephyr_getline_init ();
jerry_init (JERRY_INIT_EMPTY);
register_js_function ("print", jerryx_handler_print);
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t print_func_name_val = jerry_string_sz ("print");
print_function = jerry_object_get (global_obj_val, print_func_name_val);
jerry_value_free (print_func_name_val);
jerry_value_free (global_obj_val);
if (jerry_value_is_exception (print_function))
{
printf ("Error: could not look up print function, expression results won't be printed\n");
}
while (1)
{
char *s;
printf ("js> ");
fflush (stdout);
s = zephyr_getline ();
if (*s)
{
shell_cmd_handler (s);
}
}
/* As we never retturn from REPL above, don't call jerry_cleanup() here. */
} /* main */