Remove printf calls from jerry core

LaszloLango · LaszloLango · commit 144d58d3a9a2 · 2016-07-14T13:25:18.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",
@@ -97,11 +97,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 +115,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
@@ -650,27 +650,30 @@ jmem_heap_stats_reset_peak (void)
 void
 jmem_heap_stats_print (void)
 {
-  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",
-          jmem_heap_stats.size,
-          jmem_heap_stats.allocated_bytes,
-          jmem_heap_stats.waste_bytes,
-          jmem_heap_stats.peak_allocated_bytes,
-          jmem_heap_stats.peak_waste_bytes,
-          jmem_heap_stats.skip_count / jmem_heap_stats.nonskip_count,
-          jmem_heap_stats.skip_count % jmem_heap_stats.nonskip_count * 10000 / jmem_heap_stats.nonskip_count,
-          jmem_heap_stats.alloc_iter_count / jmem_heap_stats.alloc_count,
-          jmem_heap_stats.alloc_iter_count % jmem_heap_stats.alloc_count * 10000 / jmem_heap_stats.alloc_count,
-          jmem_heap_stats.free_iter_count / jmem_heap_stats.free_count,
-          jmem_heap_stats.free_iter_count % jmem_heap_stats.free_count * 10000 / jmem_heap_stats.free_count);
+  jerry_port_console ("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",
+                      jmem_heap_stats.size,
+                      jmem_heap_stats.allocated_bytes,
+                      jmem_heap_stats.waste_bytes,
+                      jmem_heap_stats.peak_allocated_bytes,
+                      jmem_heap_stats.peak_waste_bytes,
+                      jmem_heap_stats.skip_count / jmem_heap_stats.nonskip_count,
+                      jmem_heap_stats.skip_count % jmem_heap_stats.nonskip_count
+                                                 * 10000 / jmem_heap_stats.nonskip_count,
+                      jmem_heap_stats.alloc_iter_count / jmem_heap_stats.alloc_count,
+                      jmem_heap_stats.alloc_iter_count % jmem_heap_stats.alloc_count
+                                                       * 10000 / jmem_heap_stats.alloc_count,
+                      jmem_heap_stats.free_iter_count / jmem_heap_stats.free_count,
+                      jmem_heap_stats.free_iter_count % jmem_heap_stats.free_count
+                                                      * 10000 / jmem_heap_stats.free_count);
 } /* jmem_heap_stats_print */
 
 /**
diff --git a/jerry-core/jmem/jmem-poolman.c b/jerry-core/jmem/jmem-poolman.c
@@ -220,18 +220,19 @@ jmem_pools_stats_reset_peak (void)
 void
 jmem_pools_stats_print (void)
 {
-  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,
-          jmem_pools_stats.pools_count,
-          jmem_pools_stats.peak_pools_count,
-          jmem_pools_stats.free_chunks,
-          jmem_pools_stats.reused_count / jmem_pools_stats.new_alloc_count,
-          jmem_pools_stats.reused_count % jmem_pools_stats.new_alloc_count * 10000 / jmem_pools_stats.new_alloc_count);
+  jerry_port_console ("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,
+                      jmem_pools_stats.pools_count,
+                      jmem_pools_stats.peak_pools_count,
+                      jmem_pools_stats.free_chunks,
+                      jmem_pools_stats.reused_count / jmem_pools_stats.new_alloc_count,
+                      jmem_pools_stats.reused_count % jmem_pools_stats.new_alloc_count
+                                                    * 10000 / jmem_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
@@ -33,13 +33,13 @@ void __noreturn
 jerry_fatal (jerry_fatal_code_t code) /**< status code */
 {
 #ifndef JERRY_NDEBUG
-  printf ("Error: ");
+  jerry_port_console ("Error: ");
 
   switch (code)
   {
     case ERR_OUT_OF_MEMORY:
     {
-      printf ("ERR_OUT_OF_MEMORY\n");
+      jerry_port_console ("ERR_OUT_OF_MEMORY\n");
       break;
     }
     case ERR_SYSCALL:
@@ -49,17 +49,17 @@ jerry_fatal (jerry_fatal_code_t code) /**< status code */
     }
     case ERR_REF_COUNT_LIMIT:
     {
-      printf ("ERR_REF_COUNT_LIMIT\n");
+      jerry_port_console ("ERR_REF_COUNT_LIMIT\n");
       break;
     }
     case ERR_UNIMPLEMENTED_CASE:
     {
-      printf ("ERR_UNIMPLEMENTED_CASE\n");
+      jerry_port_console ("ERR_UNIMPLEMENTED_CASE\n");
       break;
     }
     case ERR_FAILED_INTERNAL_ASSERTION:
     {
-      printf ("ERR_FAILED_INTERNAL_ASSERTION\n");
+      jerry_port_console ("ERR_FAILED_INTERNAL_ASSERTION\n");
       break;
     }
   }
@@ -83,8 +83,11 @@ 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_console ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",
+                      assertion,
+                      file,
+                      function,
+                      (unsigned long) line);
 #else /* JERRY_NDEBUG */
   (void) assertion;
   (void) file;
@@ -106,7 +109,10 @@ 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_console ("ICE: Unreachable control path at %s(%s):%lu was executed",
+                      file,
+                      function,
+                      (unsigned long) line);
 #else /* JERRY_NDEBUG */
   (void) file;
   (void) function;
@@ -115,9 +121,10 @@ jerry_unreachable (const char *comment, /**< comment to unreachable mark if exis
 
   if (comment != NULL)
   {
-    printf ("(%s)", comment);
+    jerry_port_console ("(%s)", comment);
   }
-  printf (".\n");
+
+  jerry_port_console (".\n");
 
   jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);
 } /* jerry_unreachable */
@@ -133,7 +140,10 @@ 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_console ("SORRY: Unimplemented case at %s(%s):%lu was executed",
+                      file,
+                      function,
+                      (unsigned long) line);
 #else /* JERRY_NDEBUG */
   (void) file;
   (void) function;
@@ -142,9 +152,10 @@ jerry_unimplemented (const char *comment, /**< comment to unimplemented mark if
 
   if (comment != NULL)
   {
-    printf ("(%s)", comment);
+    jerry_port_console ("(%s)", comment);
   }
-  printf (".\n");
+
+  jerry_port_console (".\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_console ("%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_console ("%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_console ("var_ident(");
     }
     else
     {
-      printf ("ident(");
+      jerry_port_console ("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_console ("function");
     return;
   }
   else if (literal_p->type == LEXER_STRING_LITERAL)
   {
-    printf ("string(");
+    jerry_port_console ("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_console ("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_console ("regexp");
     return;
   }
   else
   {
-    printf ("unknown");
+    jerry_port_console ("unknown");
     return;
   }
 
-  printf (")");
+  jerry_port_console (")");
 } /* 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_console ("  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
@@ -170,39 +170,39 @@ parser_flush_cbc (parser_context_t *context_p) /**< context */
       name_p = cbc_ext_names[PARSER_GET_EXT_OPCODE (context_p->last_cbc_opcode)];
     }
 
-    printf ("  [%3d] %s", (int) context_p->stack_depth, name_p);
+    jerry_port_console ("  [%3d] %s", (int) context_p->stack_depth, name_p);
 
     if (flags & (CBC_HAS_LITERAL_ARG | CBC_HAS_LITERAL_ARG2))
     {
       uint16_t literal_index = context_p->last_cbc.literal_index;
       lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);
-      printf (" idx:%d->", literal_index);
+      jerry_port_console (" idx:%d->", literal_index);
       util_print_literal (literal_p);
     }
 
     if (flags & CBC_HAS_LITERAL_ARG2)
     {
       uint16_t literal_index = context_p->last_cbc.value;
       lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);
-      printf (" idx:%d->", literal_index);
+      jerry_port_console (" idx:%d->", literal_index);
       util_print_literal (literal_p);
 
       if (!(flags & CBC_HAS_LITERAL_ARG))
       {
         literal_index = context_p->last_cbc.third_literal_index;
 
         lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);
-        printf (" idx:%d->", literal_index);
+        jerry_port_console (" idx:%d->", literal_index);
         util_print_literal (literal_p);
       }
     }
 
     if (flags & CBC_HAS_BYTE_ARG)
     {
-      printf (" byte_arg:%d", (int) context_p->last_cbc.value);
+      jerry_port_console (" byte_arg:%d", (int) context_p->last_cbc.value);
     }
 
-    printf ("\n");
+    jerry_port_console ("\n");
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -327,7 +327,7 @@ parser_emit_cbc_push_number (parser_context_t *context_p, /**< context */
       real_value = -real_value;
     }
 
-    printf ("  [%3d] %s number:%d\n", (int) context_p->stack_depth, cbc_names[opcode], real_value);
+    jerry_port_console ("  [%3d] %s number:%d\n", (int) context_p->stack_depth, cbc_names[opcode], real_value);
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
@@ -391,11 +391,11 @@ parser_emit_cbc_forward_branch (parser_context_t *context_p, /**< context */
   {
     if (extra_byte_code_increase == 0)
     {
-      printf ("  [%3d] %s\n", (int) context_p->stack_depth, cbc_names[opcode]);
+      jerry_port_console ("  [%3d] %s\n", (int) context_p->stack_depth, cbc_names[opcode]);
     }
     else
     {
-      printf ("  [%3d] %s\n", (int) context_p->stack_depth, cbc_ext_names[opcode]);
+      jerry_port_console ("  [%3d] %s\n", (int) context_p->stack_depth, cbc_ext_names[opcode]);
     }
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
@@ -506,7 +506,7 @@ parser_emit_cbc_backward_branch (parser_context_t *context_p, /**< context */
 #ifdef PARSER_DUMP_BYTE_CODE
   if (context_p->is_show_opcodes)
   {
-    printf ("  [%3d] %s\n", (int) context_p->stack_depth, name);
+    jerry_port_console ("  [%3d] %s\n", (int) context_p->stack_depth, name);
   }
 #endif /* PARSER_DUMP_BYTE_CODE */
 
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",`
`@@ -97,11 +97,11 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /*< this argument /`
`97`	`97`
`98`	`98`	`if (code_unit == LIT_CHAR_NULL)`
`99`	`99`	`{`
`100`		`- printf ("\\u0000");`
	`100`	`+ jerry_port_console ("\\u0000");`
`101`	`101`	`}`
`102`	`102`	`else if (code_unit <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)`
`103`	`103`	`{`
`104`		`- printf ("%c", (char) code_unit);`
	`104`	`+ jerry_port_console ("%c", (char) code_unit);`
`105`	`105`	`}`
`106`	`106`	`else`
`107`	`107`	`{`
`@@ -115,21 +115,21 @@ ecma_builtin_global_object_print (ecma_value_t this_arg, /*< this argument /`
`115`	`115`	`0,`
`116`	`116`	`JERRY_BITSINBYTE);`
`117`	`117`
`118`		`- printf ("\\u%02x%02x", byte_high, byte_low);`
	`118`	`+ jerry_port_console ("\\u%02x%02x", byte_high, byte_low);`
`119`	`119`	`}`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`if (arg_index < args_number - 1)`
`123`	`123`	`{`
`124`		`- printf (" ");`
	`124`	`+ jerry_port_console (" ");`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`JMEM_FINALIZE_LOCAL_ARRAY (utf8_str_p);`
`128`	`128`
`129`	`129`	`ECMA_FINALIZE (str_value);`
`130`	`130`	`}`
`131`	`131`
`132`		`- printf ("\n");`
	`132`	`+ jerry_port_console ("\n");`
`133`	`133`
`134`	`134`	`if (ecma_is_value_empty (ret_value))`
`135`	`135`	`{`
Original file line number	Diff line number	Diff line change
`@@ -33,13 +33,13 @@ void __noreturn`
`33`	`33`	`jerry_fatal (jerry_fatal_code_t code) /*< status code /`
`34`	`34`	`{`
`35`	`35`	`#ifndef JERRY_NDEBUG`
`36`		`- printf ("Error: ");`
	`36`	`+ jerry_port_console ("Error: ");`
`37`	`37`
`38`	`38`	`switch (code)`
`39`	`39`	`{`
`40`	`40`	`case ERR_OUT_OF_MEMORY:`
`41`	`41`	`{`
`42`		`- printf ("ERR_OUT_OF_MEMORY\n");`
	`42`	`+ jerry_port_console ("ERR_OUT_OF_MEMORY\n");`
`43`	`43`	`break;`
`44`	`44`	`}`
`45`	`45`	`case ERR_SYSCALL:`
`@@ -49,17 +49,17 @@ jerry_fatal (jerry_fatal_code_t code) /*< status code /`
`49`	`49`	`}`
`50`	`50`	`case ERR_REF_COUNT_LIMIT:`
`51`	`51`	`{`
`52`		`- printf ("ERR_REF_COUNT_LIMIT\n");`
	`52`	`+ jerry_port_console ("ERR_REF_COUNT_LIMIT\n");`
`53`	`53`	`break;`
`54`	`54`	`}`
`55`	`55`	`case ERR_UNIMPLEMENTED_CASE:`
`56`	`56`	`{`
`57`		`- printf ("ERR_UNIMPLEMENTED_CASE\n");`
	`57`	`+ jerry_port_console ("ERR_UNIMPLEMENTED_CASE\n");`
`58`	`58`	`break;`
`59`	`59`	`}`
`60`	`60`	`case ERR_FAILED_INTERNAL_ASSERTION:`
`61`	`61`	`{`
`62`		`- printf ("ERR_FAILED_INTERNAL_ASSERTION\n");`
	`62`	`+ jerry_port_console ("ERR_FAILED_INTERNAL_ASSERTION\n");`
`63`	`63`	`break;`
`64`	`64`	`}`
`65`	`65`	`}`
`@@ -83,8 +83,11 @@ jerry_assert_fail (const char assertion, /< assertion condition string /`
`83`	`83`	`const uint32_t line) /*< line /`
`84`	`84`	`{`
`85`	`85`	`#ifndef JERRY_NDEBUG`
`86`		`- printf ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",`
`87`		`- assertion, file, function, (unsigned long) line);`
	`86`	`+ jerry_port_console ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",`
	`87`	`+ assertion,`
	`88`	`+ file,`
	`89`	`+ function,`
	`90`	`+ (unsigned long) line);`
`88`	`91`	`#else /* JERRY_NDEBUG */`
`89`	`92`	`(void) assertion;`
`90`	`93`	`(void) file;`
`@@ -106,7 +109,10 @@ jerry_unreachable (const char comment, /*< comment to unreachable mark if exis`
`106`	`109`	`const uint32_t line) /*< line /`
`107`	`110`	`{`
`108`	`111`	`#ifndef JERRY_NDEBUG`
`109`		`- printf ("ICE: Unreachable control path at %s(%s):%lu was executed", file, function, (unsigned long) line);`
	`112`	`+ jerry_port_console ("ICE: Unreachable control path at %s(%s):%lu was executed",`
	`113`	`+ file,`
	`114`	`+ function,`
	`115`	`+ (unsigned long) line);`
`110`	`116`	`#else /* JERRY_NDEBUG */`
`111`	`117`	`(void) file;`
`112`	`118`	`(void) function;`
`@@ -115,9 +121,10 @@ jerry_unreachable (const char comment, /*< comment to unreachable mark if exis`
`115`	`121`
`116`	`122`	`if (comment != NULL)`
`117`	`123`	`{`
`118`		`- printf ("(%s)", comment);`
	`124`	`+ jerry_port_console ("(%s)", comment);`
`119`	`125`	`}`
`120`		`- printf (".\n");`
	`126`	`+`
	`127`	`+ jerry_port_console (".\n");`
`121`	`128`
`122`	`129`	`jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);`
`123`	`130`	`} /* jerry_unreachable */`
`@@ -133,7 +140,10 @@ jerry_unimplemented (const char comment, /*< comment to unimplemented mark if`
`133`	`140`	`const uint32_t line) /*< line /`
`134`	`141`	`{`
`135`	`142`	`#ifndef JERRY_NDEBUG`
`136`		`- printf ("SORRY: Unimplemented case at %s(%s):%lu was executed", file, function, (unsigned long) line);`
	`143`	`+ jerry_port_console ("SORRY: Unimplemented case at %s(%s):%lu was executed",`
	`144`	`+ file,`
	`145`	`+ function,`
	`146`	`+ (unsigned long) line);`
`137`	`147`	`#else /* JERRY_NDEBUG */`
`138`	`148`	`(void) file;`
`139`	`149`	`(void) function;`
`@@ -142,9 +152,10 @@ jerry_unimplemented (const char comment, /*< comment to unimplemented mark if`
`142`	`152`
`143`	`153`	`if (comment != NULL)`
`144`	`154`	`{`
`145`		`- printf ("(%s)", comment);`
	`155`	`+ jerry_port_console ("(%s)", comment);`
`146`	`156`	`}`
`147`		`- printf (".\n");`
	`157`	`+`
	`158`	`+ jerry_port_console (".\n");`
`148`	`159`
`149`	`160`	`jerry_fatal (ERR_UNIMPLEMENTED_CASE);`
`150`	`161`	`} /* 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_console ("%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_console ("%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_console ("var_ident(");`
`90`	`90`	`}`
`91`	`91`	`else`
`92`	`92`	`{`
`93`		`- printf ("ident(");`
	`93`	`+ jerry_port_console ("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_console ("function");`
`100`	`100`	`return;`
`101`	`101`	`}`
`102`	`102`	`else if (literal_p->type == LEXER_STRING_LITERAL)`
`103`	`103`	`{`
`104`		`- printf ("string(");`
	`104`	`+ jerry_port_console ("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_console ("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_console ("regexp");`
`119`	`119`	`return;`
`120`	`120`	`}`
`121`	`121`	`else`
`122`	`122`	`{`
`123`		`- printf ("unknown");`
	`123`	`+ jerry_port_console ("unknown");`
`124`	`124`	`return;`
`125`	`125`	`}`
`126`	`126`
`127`		`- printf (")");`
	`127`	`+ jerry_port_console (")");`
`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_console (" Note: switch to strict mode\n\n");`
`1613`	`1613`	`}`
`1614`	`1614`	`#endif /* PARSER_DUMP_BYTE_CODE */`
`1615`	`1615`
Original file line number	Diff line number	Diff line change
`@@ -170,39 +170,39 @@ parser_flush_cbc (parser_context_t context_p) /< context /`
`170`	`170`	`name_p = cbc_ext_names[PARSER_GET_EXT_OPCODE (context_p->last_cbc_opcode)];`
`171`	`171`	`}`
`172`	`172`
`173`		`- printf (" [%3d] %s", (int) context_p->stack_depth, name_p);`
	`173`	`+ jerry_port_console (" [%3d] %s", (int) context_p->stack_depth, name_p);`
`174`	`174`
`175`	`175`	`if (flags & (CBC_HAS_LITERAL_ARG \| CBC_HAS_LITERAL_ARG2))`
`176`	`176`	`{`
`177`	`177`	`uint16_t literal_index = context_p->last_cbc.literal_index;`
`178`	`178`	`lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);`
`179`		`- printf (" idx:%d->", literal_index);`
	`179`	`+ jerry_port_console (" idx:%d->", literal_index);`
`180`	`180`	`util_print_literal (literal_p);`
`181`	`181`	`}`
`182`	`182`
`183`	`183`	`if (flags & CBC_HAS_LITERAL_ARG2)`
`184`	`184`	`{`
`185`	`185`	`uint16_t literal_index = context_p->last_cbc.value;`
`186`	`186`	`lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);`
`187`		`- printf (" idx:%d->", literal_index);`
	`187`	`+ jerry_port_console (" idx:%d->", literal_index);`
`188`	`188`	`util_print_literal (literal_p);`
`189`	`189`
`190`	`190`	`if (!(flags & CBC_HAS_LITERAL_ARG))`
`191`	`191`	`{`
`192`	`192`	`literal_index = context_p->last_cbc.third_literal_index;`
`193`	`193`
`194`	`194`	`lexer_literal_t *literal_p = PARSER_GET_LITERAL (literal_index);`
`195`		`- printf (" idx:%d->", literal_index);`
	`195`	`+ jerry_port_console (" idx:%d->", literal_index);`
`196`	`196`	`util_print_literal (literal_p);`
`197`	`197`	`}`
`198`	`198`	`}`
`199`	`199`
`200`	`200`	`if (flags & CBC_HAS_BYTE_ARG)`
`201`	`201`	`{`
`202`		`- printf (" byte_arg:%d", (int) context_p->last_cbc.value);`
	`202`	`+ jerry_port_console (" byte_arg:%d", (int) context_p->last_cbc.value);`
`203`	`203`	`}`
`204`	`204`
`205`		`- printf ("\n");`
	`205`	`+ jerry_port_console ("\n");`
`206`	`206`	`}`
`207`	`207`	`#endif /* PARSER_DUMP_BYTE_CODE */`
`208`	`208`
`@@ -327,7 +327,7 @@ parser_emit_cbc_push_number (parser_context_t context_p, /< context /`
`327`	`327`	`real_value = -real_value;`
`328`	`328`	`}`
`329`	`329`
`330`		`- printf (" [%3d] %s number:%d\n", (int) context_p->stack_depth, cbc_names[opcode], real_value);`
	`330`	`+ jerry_port_console (" [%3d] %s number:%d\n", (int) context_p->stack_depth, cbc_names[opcode], real_value);`
`331`	`331`	`}`
`332`	`332`	`#endif /* PARSER_DUMP_BYTE_CODE */`
`333`	`333`
`@@ -391,11 +391,11 @@ parser_emit_cbc_forward_branch (parser_context_t context_p, /< context /`
`391`	`391`	`{`
`392`	`392`	`if (extra_byte_code_increase == 0)`
`393`	`393`	`{`
`394`		`- printf (" [%3d] %s\n", (int) context_p->stack_depth, cbc_names[opcode]);`
	`394`	`+ jerry_port_console (" [%3d] %s\n", (int) context_p->stack_depth, cbc_names[opcode]);`
`395`	`395`	`}`
`396`	`396`	`else`
`397`	`397`	`{`
`398`		`- printf (" [%3d] %s\n", (int) context_p->stack_depth, cbc_ext_names[opcode]);`
	`398`	`+ jerry_port_console (" [%3d] %s\n", (int) context_p->stack_depth, cbc_ext_names[opcode]);`
`399`	`399`	`}`
`400`	`400`	`}`
`401`	`401`	`#endif /* PARSER_DUMP_BYTE_CODE */`
`@@ -506,7 +506,7 @@ parser_emit_cbc_backward_branch (parser_context_t context_p, /< context /`
`506`	`506`	`#ifdef PARSER_DUMP_BYTE_CODE`
`507`	`507`	`if (context_p->is_show_opcodes)`
`508`	`508`	`{`
`509`		`- printf (" [%3d] %s\n", (int) context_p->stack_depth, name);`
	`509`	`+ jerry_port_console (" [%3d] %s\n", (int) context_p->stack_depth, name);`
`510`	`510`	`}`
`511`	`511`	`#endif /* PARSER_DUMP_BYTE_CODE */`
`512`	`512`