Remove printf calls from jerry core

LaszloLango · LaszloLango · commit a004375e1dd3 · 2016-07-20T12:43:14.000+02:00
Related issue: #964 JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c
@@ -51,7 +51,7 @@
 /**
  * The implementation-defined Global object's 'print' routine
  *
- * The routine converts all of its arguments to strings and outputs them using 'printf'.
+ * The routine converts all of its arguments to strings and outputs them using 'jerry_port_console'.
  *
  * Code points, with except of NUL character, that are representable with one utf8-byte
  * are outputted as is, using "%c" format argument, and other code points are outputted as "\uhhll",
@@ -68,8 +68,6 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /**< this argument */
   JERRY_UNUSED (this_arg);
   ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
 
-  /* TODO: Move the 'print' routine out of engine core. */
-
   for (ecma_length_t arg_index = 0;
        ecma_is_value_empty (ret_value) && arg_index < args_number;
        arg_index++)
@@ -97,11 +95,11 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /**< this argument */
 
       if (code_unit == LIT_CHAR_NULL)
       {
-        printf ("\\u0000");
+        jerry_port_console ("\\u0000");
       }
       else if (code_unit <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)
       {
-        printf ("%c", (char) code_unit);
+        jerry_port_console ("%c", (char) code_unit);
       }
       else
       {
@@ -115,21 +113,21 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /**< this argument */
                                                               0,
                                                               JERRY_BITSINBYTE);
 
-        printf ("\\u%02x%02x", byte_high, byte_low);
+        jerry_port_console ("\\u%02x%02x", byte_high, byte_low);
       }
     }
 
     if (arg_index < args_number - 1)
     {
-      printf (" ");
+      jerry_port_console (" ");
     }
 
     JMEM_FINALIZE_LOCAL_ARRAY (utf8_str_p);
 
     ECMA_FINALIZE (str_value);
   }
 
-  printf ("\n");
+  jerry_port_console ("\n");
 
   if (ecma_is_value_empty (ret_value))
   {
diff --git a/jerry-core/jmem/jmem-heap.c b/jerry-core/jmem/jmem-heap.c
@@ -609,27 +609,28 @@ jmem_heap_stats_print (void)
 {
   jmem_heap_stats_t *heap_stats = &JERRY_CONTEXT (jmem_heap_stats);
 
-  printf ("Heap stats:\n"
-          "  Heap size = %zu bytes\n"
-          "  Allocated = %zu bytes\n"
-          "  Waste = %zu bytes\n"
-          "  Peak allocated = %zu bytes\n"
-          "  Peak waste = %zu bytes\n"
-          "  Skip-ahead ratio = %zu.%04zu\n"
-          "  Average alloc iteration = %zu.%04zu\n"
-          "  Average free iteration = %zu.%04zu\n"
-          "\n",
-          heap_stats->size,
-          heap_stats->allocated_bytes,
-          heap_stats->waste_bytes,
-          heap_stats->peak_allocated_bytes,
-          heap_stats->peak_waste_bytes,
-          heap_stats->skip_count / heap_stats->nonskip_count,
-          heap_stats->skip_count % heap_stats->nonskip_count * 10000 / heap_stats->nonskip_count,
-          heap_stats->alloc_iter_count / heap_stats->alloc_count,
-          heap_stats->alloc_iter_count % heap_stats->alloc_count * 10000 / heap_stats->alloc_count,
-          heap_stats->free_iter_count / heap_stats->free_count,
-          heap_stats->free_iter_count % heap_stats->free_count * 10000 / heap_stats->free_count);
+  jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
+                  "Heap stats:\n"
+                  "  Heap size = %zu bytes\n"
+                  "  Allocated = %zu bytes\n"
+                  "  Waste = %zu bytes\n"
+                  "  Peak allocated = %zu bytes\n"
+                  "  Peak waste = %zu bytes\n"
+                  "  Skip-ahead ratio = %zu.%04zu\n"
+                  "  Average alloc iteration = %zu.%04zu\n"
+                  "  Average free iteration = %zu.%04zu\n"
+                  "\n",
+                  heap_stats->size,
+                  heap_stats->allocated_bytes,
+                  heap_stats->waste_bytes,
+                  heap_stats->peak_allocated_bytes,
+                  heap_stats->peak_waste_bytes,
+                  heap_stats->skip_count / heap_stats->nonskip_count,
+                  heap_stats->skip_count % heap_stats->nonskip_count * 10000 / heap_stats->nonskip_count,
+                  heap_stats->alloc_iter_count / heap_stats->alloc_count,
+                  heap_stats->alloc_iter_count % heap_stats->alloc_count * 10000 / heap_stats->alloc_count,
+                  heap_stats->free_iter_count / heap_stats->free_count,
+                  heap_stats->free_iter_count % heap_stats->free_count * 10000 / heap_stats->free_count);
 } /* jmem_heap_stats_print */
 
 /**
diff --git a/jerry-core/jmem/jmem-poolman.c b/jerry-core/jmem/jmem-poolman.c
@@ -204,18 +204,19 @@ jmem_pools_stats_print (void)
 {
   jmem_pools_stats_t *pools_stats = &JERRY_CONTEXT (jmem_pools_stats);
 
-  printf ("Pools stats:\n"
-          "  Chunk size: %zu\n"
-          "  Pool chunks: %zu\n"
-          "  Peak pool chunks: %zu\n"
-          "  Free chunks: %zu\n"
-          "  Pool reuse ratio: %zu.%04zu\n",
-          JMEM_POOL_CHUNK_SIZE,
-          pools_stats->pools_count,
-          pools_stats->peak_pools_count,
-          pools_stats->free_chunks,
-          pools_stats->reused_count / pools_stats->new_alloc_count,
-          pools_stats->reused_count % pools_stats->new_alloc_count * 10000 / pools_stats->new_alloc_count);
+  jerry_port_log (JERRY_LOG_LEVEL_DEBUG,
+                  "Pools stats:\n"
+                  "  Chunk size: %zu\n"
+                  "  Pool chunks: %zu\n"
+                  "  Peak pool chunks: %zu\n"
+                  "  Free chunks: %zu\n"
+                  "  Pool reuse ratio: %zu.%04zu\n",
+                  JMEM_POOL_CHUNK_SIZE,
+                  pools_stats->pools_count,
+                  pools_stats->peak_pools_count,
+                  pools_stats->free_chunks,
+                  pools_stats->reused_count / pools_stats->new_alloc_count,
+                  pools_stats->reused_count % pools_stats->new_alloc_count * 10000 / pools_stats->new_alloc_count);
 } /* jmem_pools_stats_print */
 
 /**
diff --git a/jerry-core/jrt/jrt-fatals.c b/jerry-core/jrt/jrt-fatals.c
@@ -1,4 +1,5 @@
 /* Copyright 2014-2016 Samsung Electronics Co., Ltd.
+ * Copyright 2016 University of Szeged.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,13 +34,13 @@ void __noreturn
 jerry_fatal (jerry_fatal_code_t code) /**< status code */
 {
 #ifndef JERRY_NDEBUG
-  printf ("Error: ");
+  jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: ");
 
   switch (code)
   {
     case ERR_OUT_OF_MEMORY:
     {
-      printf ("ERR_OUT_OF_MEMORY\n");
+      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_OUT_OF_MEMORY\n");
       break;
     }
     case ERR_SYSCALL:
@@ -49,17 +50,17 @@ jerry_fatal (jerry_fatal_code_t code) /**< status code */
     }
     case ERR_REF_COUNT_LIMIT:
     {
-      printf ("ERR_REF_COUNT_LIMIT\n");
+      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_REF_COUNT_LIMIT\n");
       break;
     }
     case ERR_UNIMPLEMENTED_CASE:
     {
-      printf ("ERR_UNIMPLEMENTED_CASE\n");
+      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_UNIMPLEMENTED_CASE\n");
       break;
     }
     case ERR_FAILED_INTERNAL_ASSERTION:
     {
-      printf ("ERR_FAILED_INTERNAL_ASSERTION\n");
+      jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_FAILED_INTERNAL_ASSERTION\n");
       break;
     }
   }
@@ -83,8 +84,12 @@ jerry_assert_fail (const char *assertion, /**< assertion condition string */
                    const uint32_t line) /**< line */
 {
 #ifndef JERRY_NDEBUG
-  printf ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",
-          assertion, file, function, (unsigned long) line);
+  jerry_port_log (JERRY_LOG_LEVEL_ERROR,
+                  "ICE: Assertion '%s' failed at %s(%s):%lu.\n",
+                  assertion,
+                  file,
+                  function,
+                  (unsigned long) line);
 #else /* JERRY_NDEBUG */
   (void) assertion;
   (void) file;
@@ -106,7 +111,11 @@ jerry_unreachable (const char *comment, /**< comment to unreachable mark if exis
                    const uint32_t line) /**< line */
 {
 #ifndef JERRY_NDEBUG
-  printf ("ICE: Unreachable control path at %s(%s):%lu was executed", file, function, (unsigned long) line);
+  jerry_port_log (JERRY_LOG_LEVEL_ERROR,
+                  "ICE: Unreachable control path at %s(%s):%lu was executed",
+                  file,
+                  function,
+                  (unsigned long) line);
 #else /* JERRY_NDEBUG */
   (void) file;
   (void) function;
@@ -115,9 +124,10 @@ jerry_unreachable (const char *comment, /**< comment to unreachable mark if exis
 
   if (comment != NULL)
   {
-    printf ("(%s)", comment);
+    jerry_port_log (JERRY_LOG_LEVEL_ERROR, "(%s)", comment);
   }
-  printf (".\n");
+
+  jerry_port_log (JERRY_LOG_LEVEL_ERROR, ".\n");
 
   jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);
 } /* jerry_unreachable */
@@ -133,7 +143,11 @@ jerry_unimplemented (const char *comment, /**< comment to unimplemented mark if
                      const uint32_t line) /**< line */
 {
 #ifndef JERRY_NDEBUG
-  printf ("SORRY: Unimplemented case at %s(%s):%lu was executed", file, function, (unsigned long) line);
+  jerry_port_log (JERRY_LOG_LEVEL_ERROR,
+                  "SORRY: Unimplemented case at %s(%s):%lu was executed",
+                  file,
+                  function,
+                  (unsigned long) line);
 #else /* JERRY_NDEBUG */
   (void) file;
   (void) function;
@@ -142,9 +156,10 @@ jerry_unimplemented (const char *comment, /**< comment to unimplemented mark if
 
   if (comment != NULL)
   {
-    printf ("(%s)", comment);
+    jerry_port_log (JERRY_LOG_LEVEL_ERROR, "(%s)", comment);
   }
-  printf (".\n");
+
+  jerry_port_log (JERRY_LOG_LEVEL_ERROR, ".\n");
 
   jerry_fatal (ERR_UNIMPLEMENTED_CASE);
 } /* jerry_unimplemented */
diff --git a/jerry-core/parser/js/common.c b/jerry-core/parser/js/common.c
@@ -59,7 +59,7 @@ util_print_chars (const uint8_t *char_p, /**< character pointer */
 {
   while (size > 0)
   {
-    printf ("%c", *char_p++);
+    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "%c", *char_p++);
     size--;
   }
 } /* util_print_chars */
@@ -73,7 +73,7 @@ util_print_number (ecma_number_t num_p) /**< number to print */
   lit_utf8_byte_t str_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];
   lit_utf8_size_t str_size = ecma_number_to_utf8_string (num_p, str_buf, sizeof (str_buf));
   str_buf[str_size] = 0;
-  printf ("%s", str_buf);
+  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "%s", str_buf);
 } /* util_print_number */
 
 /**
@@ -86,22 +86,22 @@ util_print_literal (lexer_literal_t *literal_p) /**< literal */
   {
     if (literal_p->status_flags & LEXER_FLAG_VAR)
     {
-      printf ("var_ident(");
+      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "var_ident(");
     }
     else
     {
-      printf ("ident(");
+      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "ident(");
     }
     util_print_chars (literal_p->u.char_p, literal_p->prop.length);
   }
   else if (literal_p->type == LEXER_FUNCTION_LITERAL)
   {
-    printf ("function");
+    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "function");
     return;
   }
   else if (literal_p->type == LEXER_STRING_LITERAL)
   {
-    printf ("string(");
+    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "string(");
     util_print_chars (literal_p->u.char_p, literal_p->prop.length);
   }
   else if (literal_p->type == LEXER_NUMBER_LITERAL)
@@ -110,21 +110,21 @@ util_print_literal (lexer_literal_t *literal_p) /**< literal */
 
     JERRY_ASSERT (ECMA_STRING_GET_CONTAINER (value_p) == ECMA_STRING_LITERAL_NUMBER);
 
-    printf ("number(");
+    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "number(");
     util_print_number (ecma_get_number_from_value (value_p->u.lit_number));
   }
   else if (literal_p->type == LEXER_REGEXP_LITERAL)
   {
-    printf ("regexp");
+    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "regexp");
     return;
   }
   else
   {
-    printf ("unknown");
+    jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "unknown");
     return;
   }
 
-  printf (")");
+  jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ")");
 } /* util_print_literal */
 
 #endif /* PARSER_DUMP_BYTE_CODE */
diff --git a/jerry-core/parser/js/js-parser-statm.c b/jerry-core/parser/js/js-parser-statm.c
@@ -1609,7 +1609,7 @@ parser_parse_statements (parser_context_t *context_p) /**< context */
     if (context_p->is_show_opcodes
         && switch_to_strict_mode)
     {
-      printf ("  Note: switch to strict mode\n\n");
+      jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "  Note: switch to strict mode\n\n");
     }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
diff --git a/jerry-core/parser/js/js-parser-util.c b/jerry-core/parser/js/js-parser-util.c
diff --git a/jerry-core/parser/js/js-parser.c b/jerry-core/parser/js/js-parser.c
diff --git a/main-unix.c b/main-unix.c

Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@`
`51`	`51`	`/**`
`52`	`52`	`* The implementation-defined Global object's 'print' routine`
`53`	`53`	`*`
`54`		`- * The routine converts all of its arguments to strings and outputs them using 'printf'.`
	`54`	`+ * The routine converts all of its arguments to strings and outputs them using 'jerry_port_console'.`
`55`	`55`	`*`
`56`	`56`	`* Code points, with except of NUL character, that are representable with one utf8-byte`
`57`	`57`	`* are outputted as is, using "%c" format argument, and other code points are outputted as "\uhhll",`
`@@ -68,8 +68,6 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /*< this argument /`
`68`	`68`	`JERRY_UNUSED (this_arg);`
`69`	`69`	`ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);`
`70`	`70`
`71`		`- /* TODO: Move the 'print' routine out of engine core. */`
`72`		`-`
`73`	`71`	`for (ecma_length_t arg_index = 0;`
`74`	`72`	`ecma_is_value_empty (ret_value) && arg_index < args_number;`
`75`	`73`	`arg_index++)`
`@@ -97,11 +95,11 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /*< this argument /`
`97`	`95`
`98`	`96`	`if (code_unit == LIT_CHAR_NULL)`
`99`	`97`	`{`
`100`		`- printf ("\\u0000");`
	`98`	`+ jerry_port_console ("\\u0000");`
`101`	`99`	`}`
`102`	`100`	`else if (code_unit <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)`
`103`	`101`	`{`
`104`		`- printf ("%c", (char) code_unit);`
	`102`	`+ jerry_port_console ("%c", (char) code_unit);`
`105`	`103`	`}`
`106`	`104`	`else`
`107`	`105`	`{`
`@@ -115,21 +113,21 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /*< this argument /`
`115`	`113`	`0,`
`116`	`114`	`JERRY_BITSINBYTE);`
`117`	`115`
`118`		`- printf ("\\u%02x%02x", byte_high, byte_low);`
	`116`	`+ jerry_port_console ("\\u%02x%02x", byte_high, byte_low);`
`119`	`117`	`}`
`120`	`118`	`}`
`121`	`119`
`122`	`120`	`if (arg_index < args_number - 1)`
`123`	`121`	`{`
`124`		`- printf (" ");`
	`122`	`+ jerry_port_console (" ");`
`125`	`123`	`}`
`126`	`124`
`127`	`125`	`JMEM_FINALIZE_LOCAL_ARRAY (utf8_str_p);`
`128`	`126`
`129`	`127`	`ECMA_FINALIZE (str_value);`
`130`	`128`	`}`
`131`	`129`
`132`		`- printf ("\n");`
	`130`	`+ jerry_port_console ("\n");`
`133`	`131`
`134`	`132`	`if (ecma_is_value_empty (ret_value))`
`135`	`133`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,5 @@`
`1`	`1`	`/* Copyright 2014-2016 Samsung Electronics Co., Ltd.`
	`2`	`+ * Copyright 2016 University of Szeged.`
`2`	`3`	`*`
`3`	`4`	`* Licensed under the Apache License, Version 2.0 (the "License");`
`4`	`5`	`* you may not use this file except in compliance with the License.`
`@@ -33,13 +34,13 @@ void __noreturn`
`33`	`34`	`jerry_fatal (jerry_fatal_code_t code) /*< status code /`
`34`	`35`	`{`
`35`	`36`	`#ifndef JERRY_NDEBUG`
`36`		`- printf ("Error: ");`
	`37`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: ");`
`37`	`38`
`38`	`39`	`switch (code)`
`39`	`40`	`{`
`40`	`41`	`case ERR_OUT_OF_MEMORY:`
`41`	`42`	`{`
`42`		`- printf ("ERR_OUT_OF_MEMORY\n");`
	`43`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_OUT_OF_MEMORY\n");`
`43`	`44`	`break;`
`44`	`45`	`}`
`45`	`46`	`case ERR_SYSCALL:`
`@@ -49,17 +50,17 @@ jerry_fatal (jerry_fatal_code_t code) /*< status code /`
`49`	`50`	`}`
`50`	`51`	`case ERR_REF_COUNT_LIMIT:`
`51`	`52`	`{`
`52`		`- printf ("ERR_REF_COUNT_LIMIT\n");`
	`53`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_REF_COUNT_LIMIT\n");`
`53`	`54`	`break;`
`54`	`55`	`}`
`55`	`56`	`case ERR_UNIMPLEMENTED_CASE:`
`56`	`57`	`{`
`57`		`- printf ("ERR_UNIMPLEMENTED_CASE\n");`
	`58`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_UNIMPLEMENTED_CASE\n");`
`58`	`59`	`break;`
`59`	`60`	`}`
`60`	`61`	`case ERR_FAILED_INTERNAL_ASSERTION:`
`61`	`62`	`{`
`62`		`- printf ("ERR_FAILED_INTERNAL_ASSERTION\n");`
	`63`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "ERR_FAILED_INTERNAL_ASSERTION\n");`
`63`	`64`	`break;`
`64`	`65`	`}`
`65`	`66`	`}`
`@@ -83,8 +84,12 @@ jerry_assert_fail (const char assertion, /< assertion condition string /`
`83`	`84`	`const uint32_t line) /*< line /`
`84`	`85`	`{`
`85`	`86`	`#ifndef JERRY_NDEBUG`
`86`		`- printf ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",`
`87`		`- assertion, file, function, (unsigned long) line);`
	`87`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR,`
	`88`	`+ "ICE: Assertion '%s' failed at %s(%s):%lu.\n",`
	`89`	`+ assertion,`
	`90`	`+ file,`
	`91`	`+ function,`
	`92`	`+ (unsigned long) line);`
`88`	`93`	`#else /* JERRY_NDEBUG */`
`89`	`94`	`(void) assertion;`
`90`	`95`	`(void) file;`
`@@ -106,7 +111,11 @@ jerry_unreachable (const char comment, /*< comment to unreachable mark if exis`
`106`	`111`	`const uint32_t line) /*< line /`
`107`	`112`	`{`
`108`	`113`	`#ifndef JERRY_NDEBUG`
`109`		`- printf ("ICE: Unreachable control path at %s(%s):%lu was executed", file, function, (unsigned long) line);`
	`114`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR,`
	`115`	`+ "ICE: Unreachable control path at %s(%s):%lu was executed",`
	`116`	`+ file,`
	`117`	`+ function,`
	`118`	`+ (unsigned long) line);`
`110`	`119`	`#else /* JERRY_NDEBUG */`
`111`	`120`	`(void) file;`
`112`	`121`	`(void) function;`
`@@ -115,9 +124,10 @@ jerry_unreachable (const char comment, /*< comment to unreachable mark if exis`
`115`	`124`
`116`	`125`	`if (comment != NULL)`
`117`	`126`	`{`
`118`		`- printf ("(%s)", comment);`
	`127`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "(%s)", comment);`
`119`	`128`	`}`
`120`		`- printf (".\n");`
	`129`	`+`
	`130`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, ".\n");`
`121`	`131`
`122`	`132`	`jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);`
`123`	`133`	`} /* jerry_unreachable */`
`@@ -133,7 +143,11 @@ jerry_unimplemented (const char comment, /*< comment to unimplemented mark if`
`133`	`143`	`const uint32_t line) /*< line /`
`134`	`144`	`{`
`135`	`145`	`#ifndef JERRY_NDEBUG`
`136`		`- printf ("SORRY: Unimplemented case at %s(%s):%lu was executed", file, function, (unsigned long) line);`
	`146`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR,`
	`147`	`+ "SORRY: Unimplemented case at %s(%s):%lu was executed",`
	`148`	`+ file,`
	`149`	`+ function,`
	`150`	`+ (unsigned long) line);`
`137`	`151`	`#else /* JERRY_NDEBUG */`
`138`	`152`	`(void) file;`
`139`	`153`	`(void) function;`
`@@ -142,9 +156,10 @@ jerry_unimplemented (const char comment, /*< comment to unimplemented mark if`
`142`	`156`
`143`	`157`	`if (comment != NULL)`
`144`	`158`	`{`
`145`		`- printf ("(%s)", comment);`
	`159`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, "(%s)", comment);`
`146`	`160`	`}`
`147`		`- printf (".\n");`
	`161`	`+`
	`162`	`+ jerry_port_log (JERRY_LOG_LEVEL_ERROR, ".\n");`
`148`	`163`
`149`	`164`	`jerry_fatal (ERR_UNIMPLEMENTED_CASE);`
`150`	`165`	`} /* jerry_unimplemented */`
Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ util_print_chars (const uint8_t char_p, /< character pointer /`
`59`	`59`	`{`
`60`	`60`	`while (size > 0)`
`61`	`61`	`{`
`62`		`- printf ("%c", *char_p++);`
	`62`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "%c", *char_p++);`
`63`	`63`	`size--;`
`64`	`64`	`}`
`65`	`65`	`} /* util_print_chars */`
`@@ -73,7 +73,7 @@ util_print_number (ecma_number_t num_p) /*< number to print /`
`73`	`73`	`lit_utf8_byte_t str_buf[ECMA_MAX_CHARS_IN_STRINGIFIED_NUMBER];`
`74`	`74`	`lit_utf8_size_t str_size = ecma_number_to_utf8_string (num_p, str_buf, sizeof (str_buf));`
`75`	`75`	`str_buf[str_size] = 0;`
`76`		`- printf ("%s", str_buf);`
	`76`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "%s", str_buf);`
`77`	`77`	`} /* util_print_number */`
`78`	`78`
`79`	`79`	`/**`
`@@ -86,22 +86,22 @@ util_print_literal (lexer_literal_t literal_p) /< literal /`
`86`	`86`	`{`
`87`	`87`	`if (literal_p->status_flags & LEXER_FLAG_VAR)`
`88`	`88`	`{`
`89`		`- printf ("var_ident(");`
	`89`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "var_ident(");`
`90`	`90`	`}`
`91`	`91`	`else`
`92`	`92`	`{`
`93`		`- printf ("ident(");`
	`93`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "ident(");`
`94`	`94`	`}`
`95`	`95`	`util_print_chars (literal_p->u.char_p, literal_p->prop.length);`
`96`	`96`	`}`
`97`	`97`	`else if (literal_p->type == LEXER_FUNCTION_LITERAL)`
`98`	`98`	`{`
`99`		`- printf ("function");`
	`99`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "function");`
`100`	`100`	`return;`
`101`	`101`	`}`
`102`	`102`	`else if (literal_p->type == LEXER_STRING_LITERAL)`
`103`	`103`	`{`
`104`		`- printf ("string(");`
	`104`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "string(");`
`105`	`105`	`util_print_chars (literal_p->u.char_p, literal_p->prop.length);`
`106`	`106`	`}`
`107`	`107`	`else if (literal_p->type == LEXER_NUMBER_LITERAL)`
`@@ -110,21 +110,21 @@ util_print_literal (lexer_literal_t literal_p) /< literal /`
`110`	`110`
`111`	`111`	`JERRY_ASSERT (ECMA_STRING_GET_CONTAINER (value_p) == ECMA_STRING_LITERAL_NUMBER);`
`112`	`112`
`113`		`- printf ("number(");`
	`113`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "number(");`
`114`	`114`	`util_print_number (ecma_get_number_from_value (value_p->u.lit_number));`
`115`	`115`	`}`
`116`	`116`	`else if (literal_p->type == LEXER_REGEXP_LITERAL)`
`117`	`117`	`{`
`118`		`- printf ("regexp");`
	`118`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "regexp");`
`119`	`119`	`return;`
`120`	`120`	`}`
`121`	`121`	`else`
`122`	`122`	`{`
`123`		`- printf ("unknown");`
	`123`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, "unknown");`
`124`	`124`	`return;`
`125`	`125`	`}`
`126`	`126`
`127`		`- printf (")");`
	`127`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, ")");`
`128`	`128`	`} /* util_print_literal */`
`129`	`129`
`130`	`130`	`#endif /* PARSER_DUMP_BYTE_CODE */`
Original file line number	Diff line number	Diff line change
`@@ -1609,7 +1609,7 @@ parser_parse_statements (parser_context_t context_p) /< context /`
`1609`	`1609`	`if (context_p->is_show_opcodes`
`1610`	`1610`	`&& switch_to_strict_mode)`
`1611`	`1611`	`{`
`1612`		`- printf (" Note: switch to strict mode\n\n");`
	`1612`	`+ jerry_port_log (JERRY_LOG_LEVEL_DEBUG, " Note: switch to strict mode\n\n");`
`1613`	`1613`	`}`
`1614`	`1614`	`#endif /* PARSER_DUMP_BYTE_CODE */`
`1615`	`1615`