Use port APIs instead of printf in non-debug code

François Baldassari · François Baldassari · commit 91f49c2ba7af · 2016-03-10T19:37:42.000-08:00
JerryScript-DCO-1.0-Signed-off-by: François Baldassari francois@pebble.com
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-global.c b/jerry-core/ecma/builtin-objects/ecma-builtin-global.c
@@ -97,42 +97,20 @@ ecma_builtin_global_object_print (ecma_value_t this_arg __attr_unused___, /**< t
     while (utf8_str_curr_p < utf8_str_end_p)
     {
       ecma_char_t code_point = lit_utf8_read_next (&utf8_str_curr_p);
-
-      if (code_point == LIT_CHAR_NULL)
-      {
-        printf ("\\u0000");
-      }
-      else if (code_point <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)
-      {
-        printf ("%c", (char) code_point);
-      }
-      else
-      {
-        JERRY_STATIC_ASSERT (sizeof (code_point) == 2,
-                             size_of_code_point_must_be_equal_to_2_bytes);
-
-        uint32_t byte_high = (uint32_t) JRT_EXTRACT_BIT_FIELD (ecma_char_t, code_point,
-                                                               JERRY_BITSINBYTE,
-                                                               JERRY_BITSINBYTE);
-        uint32_t byte_low = (uint32_t) JRT_EXTRACT_BIT_FIELD (ecma_char_t, code_point,
-                                                              0,
-                                                              JERRY_BITSINBYTE);
-
-        printf ("\\u%02x%02x", byte_high, byte_low);
-      }
+      lit_char_put(code_point);
     }
 
     if (arg_index < args_number - 1)
     {
-      printf (" ");
+      jerry_port_putchar (' ');
     }
 
     MEM_FINALIZE_LOCAL_ARRAY (utf8_str_p);
 
     ECMA_FINALIZE (str_value);
   }
 
-  printf ("\n");
+  jerry_port_putchar ('\n');
 
   if (ecma_is_value_empty (ret_value))
   {
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_ERROR_MSG ("Error: ");
 
   switch (code)
   {
     case ERR_OUT_OF_MEMORY:
     {
-      printf ("ERR_OUT_OF_MEMORY\n");
+      JERRY_ERROR_MSG ("ERR_OUT_OF_MEMORY\n");
       break;
     }
     case ERR_SYSCALL:
@@ -54,12 +54,12 @@ jerry_fatal (jerry_fatal_code_t code) /**< status code */
     }
     case ERR_UNIMPLEMENTED_CASE:
     {
-      printf ("ERR_UNIMPLEMENTED_CASE\n");
+      JERRY_ERROR_MSG ("ERR_UNIMPLEMENTED_CASE\n");
       break;
     }
     case ERR_FAILED_INTERNAL_ASSERTION:
     {
-      printf ("ERR_FAILED_INTERNAL_ASSERTION\n");
+      JERRY_ERROR_MSG ("ERR_FAILED_INTERNAL_ASSERTION\n");
       break;
     }
   }
@@ -92,7 +92,7 @@ jerry_assert_fail (const char *assertion, /**< assertion condition string */
                    const uint32_t line) /**< line */
 {
 #if !defined (JERRY_NDEBUG) || !defined (JERRY_DISABLE_HEAVY_DEBUG)
-  printf ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",
+  JERRY_ERROR_MSG ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",
           assertion, file, function, (unsigned long) line);
 #else /* !JERRY_NDEBUG || !JERRY_DISABLE_HEAVY_DEBUG */
   (void) assertion;
@@ -115,7 +115,8 @@ 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_ERROR_MSG ("ICE: Unreachable control path at %s(%s):%lu was executed",
+      file, function, (unsigned long) line);
 #else /* !JERRY_NDEBUG */
   (void) file;
   (void) function;
@@ -124,9 +125,9 @@ jerry_unreachable (const char *comment, /**< comment to unreachable mark if exis
 
   if (comment != NULL)
   {
-    printf ("(%s)", comment);
+    JERRY_ERROR_MSG ("(%s)", comment);
   }
-  printf (".\n");
+  JERRY_ERROR_MSG (".\n");
 
   jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);
 } /* jerry_unreachable */
@@ -142,7 +143,7 @@ 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_ERROR_MSG ("SORRY: Unimplemented case at %s(%s):%lu was executed", file, function, (unsigned long) line);
 #else /* !JERRY_NDEBUG */
   (void) file;
   (void) function;
@@ -151,9 +152,9 @@ jerry_unimplemented (const char *comment, /**< comment to unimplemented mark if
 
   if (comment != NULL)
   {
-    printf ("(%s)", comment);
+    JERRY_ERROR_MSG ("(%s)", comment);
   }
-  printf (".\n");
+  JERRY_ERROR_MSG (".\n");
 
   jerry_fatal (ERR_UNIMPLEMENTED_CASE);
 } /* jerry_unimplemented */
diff --git a/jerry-core/lit/lit-char-helpers.c b/jerry-core/lit/lit-char-helpers.c
@@ -13,10 +13,13 @@
  * limitations under the License.
  */
 
+#include "jrt-bit-fields.h"
 #include "lit-char-helpers.h"
 #include "lit/lit-unicode-ranges.inc.h"
 #include "lit-strings.h"
 
+#include <stdio.h>
+
 #define NUM_OF_ELEMENTS(array) (sizeof (array) / sizeof ((array)[0]))
 
 /**
@@ -97,6 +100,43 @@ search_char_in_interval_array (ecma_char_t c,               /**< code unit */
   return false;
 } /* search_char_in_interval_array */
 
+/**
+ * Print a specified character.
+ */
+void
+lit_char_put (ecma_char_t c) /**< code unit */
+{
+  JERRY_STATIC_ASSERT (sizeof (c) == 2,
+                       size_of_code_point_must_be_equal_to_2_bytes);
+
+  if (c != LIT_CHAR_NULL && c <= LIT_UTF8_1_BYTE_CODE_POINT_MAX)
+  {
+    jerry_port_putchar ((char) c);
+  }
+  else
+  {
+    uint32_t byte_high = (uint32_t) JRT_EXTRACT_BIT_FIELD (ecma_char_t, c,
+                                                           JERRY_BITSINBYTE,
+                                                           JERRY_BITSINBYTE);
+    uint32_t byte_low = (uint32_t) JRT_EXTRACT_BIT_FIELD (ecma_char_t, c,
+                                                          0,
+                                                          JERRY_BITSINBYTE);
+
+
+    jerry_port_putchar ('\\');
+    jerry_port_putchar ('u');
+    // print high byte
+    char out_buf[3];
+    itoa(byte_high, out_buf, 16);
+    jerry_port_putchar (out_buf[0]);
+    jerry_port_putchar (out_buf[1]);
+    // print low byte
+    itoa(byte_low, out_buf, 16);
+    jerry_port_putchar (out_buf[0]);
+    jerry_port_putchar (out_buf[1]);
+  }
+} /* lit_char_put */
+
 /**
  * Check if specified character is one of the Format-Control characters
  *
diff --git a/jerry-core/lit/lit-char-helpers.h b/jerry-core/lit/lit-char-helpers.h
@@ -237,4 +237,6 @@ extern bool lit_char_is_word_char (ecma_char_t);
 ecma_length_t lit_char_to_lower_case (ecma_char_t, ecma_char_t *, ecma_length_t);
 ecma_length_t lit_char_to_upper_case (ecma_char_t, ecma_char_t *, ecma_length_t);
 
+void lit_char_put (ecma_char_t c);
+
 #endif /* !LIT_CHAR_HELPERS_H */

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_ERROR_MSG ("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_ERROR_MSG ("ERR_OUT_OF_MEMORY\n");`
`43`	`43`	`break;`
`44`	`44`	`}`
`45`	`45`	`case ERR_SYSCALL:`
`@@ -54,12 +54,12 @@ jerry_fatal (jerry_fatal_code_t code) /*< status code /`
`54`	`54`	`}`
`55`	`55`	`case ERR_UNIMPLEMENTED_CASE:`
`56`	`56`	`{`
`57`		`- printf ("ERR_UNIMPLEMENTED_CASE\n");`
	`57`	`+ JERRY_ERROR_MSG ("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_ERROR_MSG ("ERR_FAILED_INTERNAL_ASSERTION\n");`
`63`	`63`	`break;`
`64`	`64`	`}`
`65`	`65`	`}`
`@@ -92,7 +92,7 @@ jerry_assert_fail (const char assertion, /< assertion condition string /`
`92`	`92`	`const uint32_t line) /*< line /`
`93`	`93`	`{`
`94`	`94`	`#if !defined (JERRY_NDEBUG) \|\| !defined (JERRY_DISABLE_HEAVY_DEBUG)`
`95`		`- printf ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",`
	`95`	`+ JERRY_ERROR_MSG ("ICE: Assertion '%s' failed at %s(%s):%lu.\n",`
`96`	`96`	`assertion, file, function, (unsigned long) line);`
`97`	`97`	`#else /* !JERRY_NDEBUG \|\| !JERRY_DISABLE_HEAVY_DEBUG */`
`98`	`98`	`(void) assertion;`
`@@ -115,7 +115,8 @@ jerry_unreachable (const char comment, /*< comment to unreachable mark if exis`
`115`	`115`	`const uint32_t line) /*< line /`
`116`	`116`	`{`
`117`	`117`	`#ifndef JERRY_NDEBUG`
`118`		`- printf ("ICE: Unreachable control path at %s(%s):%lu was executed", file, function, (unsigned long) line);`
	`118`	`+ JERRY_ERROR_MSG ("ICE: Unreachable control path at %s(%s):%lu was executed",`
	`119`	`+ file, function, (unsigned long) line);`
`119`	`120`	`#else /* !JERRY_NDEBUG */`
`120`	`121`	`(void) file;`
`121`	`122`	`(void) function;`
`@@ -124,9 +125,9 @@ jerry_unreachable (const char comment, /*< comment to unreachable mark if exis`
`124`	`125`
`125`	`126`	`if (comment != NULL)`
`126`	`127`	`{`
`127`		`- printf ("(%s)", comment);`
	`128`	`+ JERRY_ERROR_MSG ("(%s)", comment);`
`128`	`129`	`}`
`129`		`- printf (".\n");`
	`130`	`+ JERRY_ERROR_MSG (".\n");`
`130`	`131`
`131`	`132`	`jerry_fatal (ERR_FAILED_INTERNAL_ASSERTION);`
`132`	`133`	`} /* jerry_unreachable */`
`@@ -142,7 +143,7 @@ jerry_unimplemented (const char comment, /*< comment to unimplemented mark if`
`142`	`143`	`const uint32_t line) /*< line /`
`143`	`144`	`{`
`144`	`145`	`#ifndef JERRY_NDEBUG`
`145`		`- printf ("SORRY: Unimplemented case at %s(%s):%lu was executed", file, function, (unsigned long) line);`
	`146`	`+ JERRY_ERROR_MSG ("SORRY: Unimplemented case at %s(%s):%lu was executed", file, function, (unsigned long) line);`
`146`	`147`	`#else /* !JERRY_NDEBUG */`
`147`	`148`	`(void) file;`
`148`	`149`	`(void) function;`
`@@ -151,9 +152,9 @@ jerry_unimplemented (const char comment, /*< comment to unimplemented mark if`
`151`	`152`
`152`	`153`	`if (comment != NULL)`
`153`	`154`	`{`
`154`		`- printf ("(%s)", comment);`
	`155`	`+ JERRY_ERROR_MSG ("(%s)", comment);`
`155`	`156`	`}`
`156`		`- printf (".\n");`
	`157`	`+ JERRY_ERROR_MSG (".\n");`
`157`	`158`
`158`	`159`	`jerry_fatal (ERR_UNIMPLEMENTED_CASE);`
`159`	`160`	`} /* jerry_unimplemented */`