UTF-8 variable name error

[weixiongmei]

When using UTF-8 variable name, the "jerry_parse" function will returns a value "1073429487", wondering how to get it fixed?

var 测试 = "您好";

[akosthekiss]

It's highly preferred to submit version info and platform info, as well as build and execution commands along issue reports to make them reproducible. Moreover, 1073429487 probably doesn't mean a thing, as jerry_parse returns a jerry_value_t, which should not be interpreted as a number.

Anyway, reproduction follows with necessary information provided:

$ uname -mrs
Darwin 18.6.0 x86_64

$ tools/build.py --clean --debug --error-messages=on --logging=on

$ build/bin/jerry --version
Version: 1.0 (dea73d87)

$ build/bin/jerry ../unicodeid.js 
var 测试 = "您好";
~~~~^
Script Error: SyntaxError: Identifier expected. [line: 1, column: 5]

[rerobika]

@weixiongmei Thanks for the report, the issue seems valid on the current master. We are going fix this issue as soon as possible.

[weixiongmei]

@rerobika Thank you so much, it would be very helpful for the people who may use UTF-8 to name the variables or functions in the js code. Also, i apologize for not reporting in the specified format, because the port of ESP32 that i'm using can't print the error message....

[weixiongmei]

@akosthekiss Hi, Can you tell how did you print the error message? I enabled the JERRY_ERROR_MESSAGES, JERRY_LINE_INFO, JERRY_LOGGING, I can manually add "prinf" to the "js-parser.c" for the error message. But, i belive it's not the right way to do it, wondering how did you print the error message from the return_value of "jerry_parse or jerry_run".

#if ENABLED (JERRY_ERROR_MESSAGES)
    const lit_utf8_byte_t *err_bytes_p = (const lit_utf8_byte_t *) parser_error_to_string (parser_error.error);
    lit_utf8_size_t err_bytes_size = lit_zt_utf8_string_size (err_bytes_p);

    ecma_string_t *err_str_p = ecma_new_ecma_string_from_utf8 (err_bytes_p, err_bytes_size);
    ecma_value_t err_str_val = ecma_make_string_value (err_str_p);
    ecma_value_t line_str_val = ecma_make_uint32_value (parser_error.line);
    ecma_value_t col_str_val = ecma_make_uint32_value (parser_error.column);

    printf("%s [line: %d, column: %d]",err_bytes_p, parser_error.line, parser_error.column);

    ecma_value_t error_value = ecma_raise_standard_error_with_format (ECMA_ERROR_SYNTAX,
                                                                      "% [line: %, column: %]",
                                                                      err_str_val,
                                                                      line_str_val,
                                                                      col_str_val);

    ecma_free_value (col_str_val);
    ecma_free_value (line_str_val);
    ecma_free_value (err_str_val);

    return error_value;
#else /* !ENABLED (JERRY_ERROR_MESSAGES) */

[akosthekiss]

@weixiongmei There should be no need to modify js-parser.c . I've used the command line utility to execute the test, which contains logic to print info about unhandled exceptions that happen during parsing or running a script. Everything happens using public API functions. Please, have a look at jerry-main/main-unix.c, especially at the print_unhandled_exception function and its call sites. That function is not part of either jerry-core or jerry-ext as it contains some code specific to jerry-main and as such it is not fully reusable (at least, at for now), but you may copy it and tailor it to your needs.

[weixiongmei]

@akosthekiss Hi, i just using the code you posted in the github a long time ago for printing the error message, but it seems like doesn't work.

void print_string_form (jerry_value_t val)
{
  jerry_value_t str_val = jerry_value_to_string (val);
  jerry_size_t str_size = jerry_get_string_size (str_val);

  jerry_char_t str_buf[str_size + 1];
  jerry_string_to_char_buffer (str_val, str_buf, str_size);

  jerry_release_value (str_val);

  printf ("Error: %s\n", str_buf);
}

void app_main()
{
  char *entry = "/spiffs/index.js";
  size_t size = 0;
  jerry_char_t *script = jerry_port_read_source(entry, &size);
  jerry_value_t parse_code = jerry_parse((jerry_char_t *)entry, strlen(entry), script, size, JERRY_PARSE_NO_OPTS);
  if (jerry_value_is_error(parse_code)) {
    print_string_form(parse_code);
  }
jerry_value_t ret_value = jerry_run(parse_code);
print_string_form(ret_value);
jerry_release_value(ret_value);
jerry_release_value(parse_code);
jerry_port_release_source(script);
}

OUTPUT ==== "print_string_form" function code you posted long time ago, outputs are not readable,

D (1474) spi_flash: trying chip: issi
D (1478) spi_flash: trying chip: generic
I (1482) spi_flash: detected chip: generic
V (1487) memspi: raw_chip_id: 1660C8

V (1490) memspi: chip_id: C86016

I (1494) spi_flash: flash io: dio
I (1498) cpu_start: Starting scheduler on PRO CPU.
D (1504) heap_init: New heap initialised at 0x3ffe0440
I (1504) spiram: Reserving pool of 32K of internal memory for DMA/internal allocations
D (1514) spiram: Allocating block of size 32768 bytes
Partition size: total: 1860161, used: 7530
heap free: 329632
V (2104) intr_alloc: esp_intr_alloc_intrstatus (cpu 0): checking args
V (2104) intr_alloc: esp_intr_alloc_intrstatus (cpu 0): Args okay. Resulting flags 0xE
D (2104) intr_alloc: Connected src 22 to int 12 (cpu 0)

List of Directory [/spiffs/]
-----------------------------------
T  Size      Date/Time         Name
-----------------------------------
f      1384  31/12/1969 23:59  index.js
f       140  31/12/1969 23:59  b.js
f       361  31/12/1969 23:59  index_performance.js
f       135  31/12/1969 23:59  a.js
f       609  31/12/1969 23:59  index_original.js
f      2591  31/12/1969 23:59  gpio.js
-----------------------------------
       5220 in 6 file(s)
-----------------------------------
SPIFFS: free 1809 KB of 1816 KB
-----------------------------------

Identifier expected. [line: 17, column: 5] <----This is modified "printf" in "js-parser.c" as mentioned above
�P@�?���?��?���?h  <---- "print_string_form" of "jerry_parse" return_value
�P@�?���?��?���?h  <---- "print_string_form" of "jerry_run" return_value

[weixiongmei]

@akosthekiss "print_unhandled_exception" is not working neither, the err_str_size returns 0.

[akosthekiss]

@weixiongmei The following minimal example works for me:

#include <stdio.h>

#include "jerryscript.h"

static void
print_exception (jerry_value_t error_value) /**< error value */
{

  jerry_value_t err_str_val = jerry_value_to_string (error_value);
  jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
  jerry_char_t err_str_buf[err_str_size + 1];

  jerry_size_t string_end = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
  err_str_buf[string_end] = 0;

  printf ("Error: %s\n", err_str_buf);
  jerry_release_value (err_str_val);
} /* print_exception */

int main (void)
{
  jerry_init (JERRY_INIT_EMPTY);

  const jerry_char_t bugous_src[] = "{";

  jerry_value_t ret_value = jerry_create_undefined ();
  ret_value = jerry_parse (NULL, 0,
                           bugous_src, sizeof (bugous_src) - 1,
                           JERRY_PARSE_NO_OPTS);

  if (jerry_value_is_error (ret_value))
  {
    ret_value = jerry_get_value_from_error (ret_value, true);
    print_exception (ret_value);
  }

  jerry_release_value (ret_value);

  return 1;
} /* main */

Its output is Error: SyntaxError: Primary expression expected. [line: 1, column: 2].

The ret_value = jerry_get_value_from_error (ret_value, true); line is an important difference compared to old code. The API around errors have changed somewhat (around #2350). See http://jerryscript.net/api-reference/#jerry_get_value_from_error . That may also affect your experience with print_unhandled_exception.

Do take a look at main-unix.c. It is always a good starting example.

[weixiongmei]

@akosthekiss Thank you so much, your minial example works like a champ now.. Hope the UTF-8 variable name issue would be fixed very soon too..

[weixiongmei]

@rerobika Can you please also fix the UTF-8 for the magic string too? The magic string does not supports UTF-8... Thanks ~~~