Reference

Termination

It is questionable whether a library should be able to terminate an application. Any API function can signal an error (ex.: cannot allocate memory), so the engine use the termination approach with this port function.

  1. /**
  2.  * Signal the port that jerry experienced a fatal failure from which it cannot
  3.  * recover.
  4.  *
  5.  * @param code gives the cause of the error.
  6.  *
  7.  * Note: jerry expects the function not to return.
  8.  *
  9.  * Example: a libc-based port may implement this with exit() or abort(), or both.
  10.  */
  11. void jerry_port_fatal (jerry_fatal_code_t code);

Error codes

  1. typedef enum
  2. {
  3.   ERR_OUT_OF_MEMORY = 10,
  4.   ERR_SYSCALL = 11,
  5.   ERR_REF_COUNT_LIMIT = 12,
  6.   ERR_FAILED_INTERNAL_ASSERTION = 120
  7. } jerry_fatal_code_t;

I/O

These are the only I/O functions jerry calls.

  1. /**
  2.  * Print a string to the console. The function should implement a printf-like
  3.  * interface, where the first argument specifies a format string on how to
  4.  * stringify the rest of the parameter list.
  5.  *
  6.  * This function is only called with strings coming from the executed ECMAScript
  7.  * wanting to print something as the result of its normal operation.
  8.  *
  9.  * It should be the port that decides what a "console" is.
  10.  *
  11.  * Example: a libc-based port may implement this with vprintf().
  12.  */
  13. void jerry_port_console (const char *fmt, ...);
  15. /**
  16.  * Jerry log levels. The levels are in severity order
  17.  * where the most serious levels come first.
  18.  */
  19. typedef enum
  20. {
  21.   JERRY_LOG_LEVEL_ERROR,    /**< the engine will terminate after the message is printed */
  22.   JERRY_LOG_LEVEL_WARNING,  /**< a request is aborted, but the engine continues its operation */
  23.   JERRY_LOG_LEVEL_DEBUG,    /**< debug messages from the engine, low volume */
  24.   JERRY_LOG_LEVEL_TRACE     /**< detailed info about engine internals, potentially high volume */
  25. } jerry_log_level_t;
  27. /**
  28.  * Display or log a debug/error message. The function should implement a printf-like
  29.  * interface, where the first argument specifies the log level
  30.  * and the second argument specifies a format string on how to stringify the rest
  31.  * of the parameter list.
  32.  *
  33.  * This function is only called with messages coming from the jerry engine as
  34.  * the result of some abnormal operation or describing its internal operations 
  35.  * (e.g., data structure dumps or tracing info).
  36.  *
  37.  * It should be the port that decides whether error and debug messages are logged to
  38.  * the console, or saved to a database or to a file.
  39.  * 
  40.  * Example: a libc-based port may implement this with vfprintf(stderr) or 
  41.  * vfprintf(logfile), or both, depending on log level.
  42.  */
  43. void jerry_port_log (jerry_log_level_t level, const char *fmt, ...);

Date

  1. /**
  2.  * Jerry time zone structure
  3.  */
  4. typedef struct
  5. {
  6.   int offset;                /**< minutes from west */
  7.   int daylight_saving_time;  /**< daylight saving time (1 - DST applies, 0 - not on DST) */
  8. } jerry_time_zone_t;
  10. /**
  11.  * Get timezone and daylight saving data
  12.  *
  13.  * @return true  - if success
  14.  *         false - otherwise
  15.  */
  16. bool jerry_port_get_time_zone (jerry_time_zone_t *);
  18. /**
  19.  * Get system time
  20.  *
  21.  * @return milliseconds since Unix epoch
  22.  */
  23. double jerry_port_get_current_time (void);

How to port JerryScript

This section describes a basic port implementation which was created for Unix based systems.

Termination

  1. #include <stdlib.h>
  2. #include "jerry-port.h"
  4. /**
  5.  * Default implementation of jerry_port_fatal.
  6.  */
  7. void jerry_port_fatal (jerry_fatal_code_t code)
  8. {
  9.   exit (code);
  10. } /* jerry_port_fatal */

I/O

  1. #include <stdarg.h>
  2. #include "jerry-port.h"
  4. /**
  5.  * Provide console message implementation for the engine.
  6.  */
  7. void
  8. jerry_port_console (const char *format, /**< format string */
  9.                     ...) /**< parameters */
  10. {
  11.   va_list args;
  12.   va_start (args, format);
  13.   vfprintf (stdout, format, args);
  14.   va_end (args);
  15. } /* jerry_port_console */
  17. /**
  18.  * Provide log message implementation for the engine.
  19.  *
  20.  * Note:
  21.  *      This example ignores the log level.
  22.  */
  23. void
  24. jerry_port_log (jerry_log_level_t level, /**< log level */
  25.                 const char *format, /**< format string */
  26.                 ...)  /**< parameters */
  27. {
  28.   va_list args;
  29.   va_start (args, format);
  30.   vfprintf (stderr, format, args);
  31.   va_end (args);
  32. } /* jerry_port_log */

Date

  1. #include <sys/time.h>
  2. #include "jerry-port.h"
  4. /**
  5.  * Default implementation of jerry_port_get_time_zone.
  6.  */
  7. bool jerry_port_get_time_zone (jerry_time_zone_t *tz_p)
  8. {
  9.   struct timeval tv;
  10.   struct timezone tz;
  12.   /* gettimeofday may not fill tz, so zero-initializing */
  13.   tz.tz_minuteswest = 0;
  14.   tz.tz_dsttime = 0;
  16.   if (gettimeofday (&tv, &tz) != 0)
  17.   {
  18.     return false;
  19.   }
  21.   tz_p->offset = tz.tz_minuteswest;
  22.   tz_p->daylight_saving_time = tz.tz_dsttime > 0 ? 1 : 0;
  24.   return true;
  25. } /* jerry_port_get_time_zone */
  27. /**
  28.  * Default implementation of jerry_port_get_current_time.
  29.  */
  30. double jerry_port_get_current_time ()
  31. {
  32.   struct timeval tv;
  34.   if (gettimeofday (&tv, NULL) != 0)
  35.   {
  36.     return 0;
  37.   }
  39.   return ((double) tv.tv_sec) * 1000.0 + ((double) tv.tv_usec) / 1000.0;
  40. } /* jerry_port_get_current_time */