Rename isalpha, isdigit and replace characters with their corresponding constant.

zherczeg · zherczeg · commit 41aef56cbaec · 2015-07-28T23:38:45.000-07:00
JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg@inf.u-szeged.hu
diff --git a/jerry-core/ecma/builtin-objects/ecma-builtin-json.cpp b/jerry-core/ecma/builtin-objects/ecma-builtin-json.cpp
@@ -39,27 +39,6 @@
 #define BUILTIN_UNDERSCORED_ID json
 #include "ecma-builtin-internal-routines-template.inc.h"
 
-/*
- * FIXME:
- *       Replace usage of isalpha and isdigit functions in the module with lit_char helpers and remove the functions.
- *
- *       Related issue: #424
- */
-
-/** Checks for an alphabetic character. */
-static int
-isalpha (int c)
-{
-  return (c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z');
-}
-
-/** Checks for a digit (0 through 9).  */
-static int
-isdigit (int c)
-{
-  return c >= '0' && c <= '9';
-}
-
 /** \addtogroup ecma ECMA
  * @{
  *
@@ -126,9 +105,16 @@ ecma_builtin_json_check_id (lit_utf8_byte_t *string_p, /**< start position */
   {
     string_p++;
     id_p++;
-    if (*id_p == '\0')
-    {
-      return !isalpha (*string_p) && !isdigit (*string_p) && *string_p != '$' && *string_p != '_';
+    if (*id_p == LIT_CHAR_NULL)
+    {
+      /* JSON lexer accepts input strings such as falsenull and
+       * returns with multiple tokens (false and null in this case).
+       * This is different from normal lexers, whose return with a
+       * single identifier. The falsenull input will still cause an
+       * error eventually, since a separator must always be present
+       * between two JSON values regardless of the current expression
+       * type. */
+      return true;
     }
   }
   while (*string_p == *id_p);
@@ -147,49 +133,49 @@ ecma_builtin_json_parse_string (ecma_json_token_t *token_p) /**< token argument
 
   token_p->u.string.start_p = current_p;
 
-  while (*current_p != '"')
+  while (*current_p != LIT_CHAR_DOUBLE_QUOTE)
   {
     if (*current_p <= 0x1f)
     {
       return;
     }
-    if (*current_p == '\\')
+    if (*current_p == LIT_CHAR_BACKSLASH)
     {
       current_p++;
       switch (*current_p)
       {
-        case '"':
-        case '/':
-        case '\\':
+        case LIT_CHAR_DOUBLE_QUOTE:
+        case LIT_CHAR_SLASH:
+        case LIT_CHAR_BACKSLASH:
         {
           break;
         }
-        case 'b':
+        case LIT_CHAR_LOWERCASE_B:
         {
-          *current_p = '\b';
+          *current_p = LIT_CHAR_BS;
           break;
         }
-        case 'f':
+        case LIT_CHAR_LOWERCASE_F:
         {
-          *current_p = '\f';
+          *current_p = LIT_CHAR_FF;
           break;
         }
-        case 'n':
+        case LIT_CHAR_LOWERCASE_N:
         {
-          *current_p = '\n';
+          *current_p = LIT_CHAR_LF;
           break;
         }
-        case 'r':
+        case LIT_CHAR_LOWERCASE_R:
         {
-          *current_p = '\r';
+          *current_p = LIT_CHAR_CR;
           break;
         }
-        case 't':
+        case LIT_CHAR_LOWERCASE_T:
         {
-          *current_p = '\t';
+          *current_p = LIT_CHAR_TAB;
           break;
         }
-        case 'u':
+        case LIT_CHAR_LOWERCASE_U:
         {
           lit_code_point_t code_point;
 
@@ -277,32 +263,32 @@ ecma_builtin_json_parse_number (ecma_json_token_t *token_p) /**< token argument
   lit_utf8_byte_t *current_p = token_p->current_p;
   lit_utf8_byte_t *start_p = current_p;
 
-  if (*current_p == '-')
+  if (*current_p == LIT_CHAR_MINUS)
   {
     current_p++;
   }
 
-  if (*current_p == '0')
+  if (*current_p == LIT_CHAR_0)
   {
     current_p++;
-    if (isdigit (*current_p))
+    if (lit_char_is_decimal_digit (*current_p))
     {
       return;
     }
   }
-  else if (isdigit (*current_p))
+  else if (lit_char_is_decimal_digit (*current_p))
   {
     do
     {
       current_p++;
     }
-    while (isdigit (*current_p));
+    while (lit_char_is_decimal_digit (*current_p));
   }
 
-  if (*current_p == '.')
+  if (*current_p == LIT_CHAR_DOT)
   {
     current_p++;
-    if (!isdigit (*current_p))
+    if (!lit_char_is_decimal_digit (*current_p))
     {
       return;
     }
@@ -311,18 +297,18 @@ ecma_builtin_json_parse_number (ecma_json_token_t *token_p) /**< token argument
     {
       current_p++;
     }
-    while (isdigit (*current_p));
+    while (lit_char_is_decimal_digit (*current_p));
   }
 
-  if (*current_p == 'e' || *current_p == 'E')
+  if (*current_p == LIT_CHAR_LOWERCASE_E || *current_p == LIT_CHAR_UPPERCASE_E)
   {
     current_p++;
-    if (*current_p == '+' || *current_p == '-')
+    if (*current_p == LIT_CHAR_PLUS || *current_p == LIT_CHAR_MINUS)
     {
       current_p++;
     }
 
-    if (!isdigit (*current_p))
+    if (!lit_char_is_decimal_digit (*current_p))
     {
       return;
     }
@@ -331,7 +317,7 @@ ecma_builtin_json_parse_number (ecma_json_token_t *token_p) /**< token argument
     {
       current_p++;
     }
-    while (isdigit (*current_p));
+    while (lit_char_is_decimal_digit (*current_p));
   }
   token_p->type = number_token;
   token_p->u.number = ecma_utf8_string_to_number (start_p, (lit_utf8_size_t) (current_p - start_p));
@@ -354,8 +340,8 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t *token_p) /**< token argum
   /*
    * No need for end check since the string is zero terminated.
    */
-  while (*current_p == ' ' || *current_p == '\r'
-         || *current_p == '\n' || *current_p == '\t')
+  while (*current_p == LIT_CHAR_SP || *current_p == LIT_CHAR_CR
+         || *current_p == LIT_CHAR_LF || *current_p == LIT_CHAR_TAB)
   {
     current_p++;
   }
@@ -368,43 +354,43 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t *token_p) /**< token argum
 
   switch (*current_p)
   {
-    case '{':
+    case LIT_CHAR_LEFT_BRACE:
     {
       token_p->type = left_brace_token;
       token_p->current_p = current_p + 1;
       return;
     }
-    case '}':
+    case LIT_CHAR_RIGHT_BRACE:
     {
       token_p->type = right_brace_token;
       token_p->current_p = current_p + 1;
       return;
     }
-    case '[':
+    case LIT_CHAR_LEFT_SQUARE:
     {
       token_p->type = left_square_token;
       token_p->current_p = current_p + 1;
       return;
     }
-    case ',':
+    case LIT_CHAR_COMMA:
     {
       token_p->type = comma_token;
       token_p->current_p = current_p + 1;
       return;
     }
-    case ':':
+    case LIT_CHAR_COLON:
     {
       token_p->type = colon_token;
       token_p->current_p = current_p + 1;
       return;
     }
-    case '"':
+    case LIT_CHAR_DOUBLE_QUOTE:
     {
       token_p->current_p = current_p + 1;
       ecma_builtin_json_parse_string (token_p);
       return;
     }
-    case 'n':
+    case LIT_CHAR_LOWERCASE_N:
     {
       if (ecma_builtin_json_check_id (current_p, "null"))
       {
@@ -414,7 +400,7 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t *token_p) /**< token argum
       }
       break;
     }
-    case 't':
+    case LIT_CHAR_LOWERCASE_T:
     {
       if (ecma_builtin_json_check_id (current_p, "true"))
       {
@@ -424,7 +410,7 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t *token_p) /**< token argum
       }
       break;
     }
-    case 'f':
+    case LIT_CHAR_LOWERCASE_F:
     {
       if (ecma_builtin_json_check_id (current_p, "false"))
       {
@@ -436,7 +422,7 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t *token_p) /**< token argum
     }
     default:
     {
-      if (*current_p == '-' || isdigit (*current_p))
+      if (*current_p == LIT_CHAR_MINUS || lit_char_is_decimal_digit (*current_p))
       {
         token_p->current_p = current_p;
         ecma_builtin_json_parse_number (token_p);
@@ -462,15 +448,15 @@ ecma_builtin_json_check_right_square_token (ecma_json_token_t *token_p) /**< tok
   /*
    * No need for end check since the string is zero terminated.
    */
-  while (*current_p == ' ' || *current_p == '\r'
-         || *current_p == '\n' || *current_p == '\t')
+  while (*current_p == LIT_CHAR_SP || *current_p == LIT_CHAR_CR
+         || *current_p == LIT_CHAR_LF || *current_p == LIT_CHAR_TAB)
   {
     current_p++;
   }
 
   token_p->current_p = current_p;
 
-  if (*current_p == ']')
+  if (*current_p == LIT_CHAR_RIGHT_SQUARE)
   {
     token_p->current_p = current_p + 1;
     return true;
@@ -1107,7 +1093,7 @@ ecma_builtin_json_stringify (ecma_value_t this_arg __attr_unused___, /**< 'this'
 
       for (int32_t i = 0; i < space; i++)
       {
-        space_buff[i] = ' ';
+        space_buff[i] = LIT_CHAR_SP;
       }
 
       context_p.gap_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) space_buff, (lit_utf8_size_t) space);
@@ -1228,7 +1214,7 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo
     lit_utf8_byte_t c = zt_string_buff[i];
 
     /* 2.a */
-    if (c == '\\' || c == '\"')
+    if (c == LIT_CHAR_BACKSLASH || c == LIT_CHAR_DOUBLE_QUOTE)
     {
       ecma_string_t *backslash_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_BACKSLASH_CHAR);
 
@@ -1247,7 +1233,8 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo
       product_str_p = tmp_str_p;
     }
     /* 2.b */
-    else if (c == '\b' || c == '\f' || c == '\n' || c == '\r' || c == '\t')
+    else if (c == LIT_CHAR_BS || c == LIT_CHAR_FF || c == LIT_CHAR_LF
+             || c == LIT_CHAR_CR || c == LIT_CHAR_TAB)
     {
       ecma_string_t *backslash_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_BACKSLASH_CHAR);
 
@@ -1258,33 +1245,33 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo
       product_str_p = tmp_str_p;
 
       /* 2.b.ii */
-      lit_utf8_byte_t abbrev = ' ';
+      lit_utf8_byte_t abbrev = LIT_CHAR_SP;
 
       switch (c)
       {
-        case '\b':
+        case LIT_CHAR_BS:
         {
-          abbrev = 'b';
+          abbrev = LIT_CHAR_LOWERCASE_B;
           break;
         }
-        case '\f':
+        case LIT_CHAR_FF:
         {
-          abbrev = 'f';
+          abbrev = LIT_CHAR_LOWERCASE_F;
           break;
         }
-        case '\n':
+        case LIT_CHAR_LF:
         {
-          abbrev = 'n';
+          abbrev = LIT_CHAR_LOWERCASE_N;
           break;
         }
-        case '\r':
+        case LIT_CHAR_CR:
         {
-          abbrev = 'r';
+          abbrev = LIT_CHAR_LOWERCASE_R;
           break;
         }
-        case '\t':
+        case LIT_CHAR_TAB:
         {
-          abbrev = 't';
+          abbrev = LIT_CHAR_LOWERCASE_T;
           break;
         }
       }
@@ -1309,7 +1296,7 @@ ecma_builtin_json_quote (ecma_string_t *string_p) /**< string that should be quo
       product_str_p = tmp_str_p;
 
       /* 2.c.ii */
-      lit_utf8_byte_t u_ch = 'u';
+      lit_utf8_byte_t u_ch = LIT_CHAR_LOWERCASE_U;
       ecma_string_t *u_ch_str_p = ecma_new_ecma_string_from_utf8 (&u_ch, 1);
 
       tmp_str_p = ecma_concat_ecma_strings (product_str_p, u_ch_str_p);

Original file line number	Diff line number	Diff line change
`@@ -39,27 +39,6 @@`
`39`	`39`	`#define BUILTIN_UNDERSCORED_ID json`
`40`	`40`	`#include "ecma-builtin-internal-routines-template.inc.h"`
`41`	`41`
`42`		`-/*`
`43`		`- * FIXME:`
`44`		`- * Replace usage of isalpha and isdigit functions in the module with lit_char helpers and remove the functions.`
`45`		`- *`
`46`		`- * Related issue: #424`
`47`		`- */`
`48`		`-`
`49`		`-/** Checks for an alphabetic character. */`
`50`		`-static int`
`51`		`-isalpha (int c)`
`52`		`-{`
`53`		`- return (c >= 'A' && c <= 'Z') \|\| (c >= 'a' && c <= 'z');`
`54`		`-}`
`55`		`-`
`56`		`-/** Checks for a digit (0 through 9). */`
`57`		`-static int`
`58`		`-isdigit (int c)`
`59`		`-{`
`60`		`- return c >= '0' && c <= '9';`
`61`		`-}`
`62`		`-`
`63`	`42`	`/** \addtogroup ecma ECMA`
`64`	`43`	`* @{`
`65`	`44`	`*`
`@@ -126,9 +105,16 @@ ecma_builtin_json_check_id (lit_utf8_byte_t string_p, /< start position /`
`126`	`105`	`{`
`127`	`106`	`string_p++;`
`128`	`107`	`id_p++;`
`129`		`- if (*id_p == '\0')`
`130`		`- {`
`131`		`- return !isalpha (string_p) && !isdigit (string_p) && string_p != '$' && string_p != '_';`
	`108`	`+ if (*id_p == LIT_CHAR_NULL)`
	`109`	`+ {`
	`110`	`+ /* JSON lexer accepts input strings such as falsenull and`
	`111`	`+ * returns with multiple tokens (false and null in this case).`
	`112`	`+ * This is different from normal lexers, whose return with a`
	`113`	`+ * single identifier. The falsenull input will still cause an`
	`114`	`+ * error eventually, since a separator must always be present`
	`115`	`+ * between two JSON values regardless of the current expression`
	`116`	`+ * type. */`
	`117`	`+ return true;`
`132`	`118`	`}`
`133`	`119`	`}`
`134`	`120`	`while (string_p == id_p);`
`@@ -147,49 +133,49 @@ ecma_builtin_json_parse_string (ecma_json_token_t token_p) /*< token argument`
`147`	`133`
`148`	`134`	`token_p->u.string.start_p = current_p;`
`149`	`135`
`150`		`- while (*current_p != '"')`
	`136`	`+ while (*current_p != LIT_CHAR_DOUBLE_QUOTE)`
`151`	`137`	`{`
`152`	`138`	`if (*current_p <= 0x1f)`
`153`	`139`	`{`
`154`	`140`	`return;`
`155`	`141`	`}`
`156`		`- if (*current_p == '\\')`
	`142`	`+ if (*current_p == LIT_CHAR_BACKSLASH)`
`157`	`143`	`{`
`158`	`144`	`current_p++;`
`159`	`145`	`switch (*current_p)`
`160`	`146`	`{`
`161`		`- case '"':`
`162`		`- case '/':`
`163`		`- case '\\':`
	`147`	`+ case LIT_CHAR_DOUBLE_QUOTE:`
	`148`	`+ case LIT_CHAR_SLASH:`
	`149`	`+ case LIT_CHAR_BACKSLASH:`
`164`	`150`	`{`
`165`	`151`	`break;`
`166`	`152`	`}`
`167`		`- case 'b':`
	`153`	`+ case LIT_CHAR_LOWERCASE_B:`
`168`	`154`	`{`
`169`		`- *current_p = '\b';`
	`155`	`+ *current_p = LIT_CHAR_BS;`
`170`	`156`	`break;`
`171`	`157`	`}`
`172`		`- case 'f':`
	`158`	`+ case LIT_CHAR_LOWERCASE_F:`
`173`	`159`	`{`
`174`		`- *current_p = '\f';`
	`160`	`+ *current_p = LIT_CHAR_FF;`
`175`	`161`	`break;`
`176`	`162`	`}`
`177`		`- case 'n':`
	`163`	`+ case LIT_CHAR_LOWERCASE_N:`
`178`	`164`	`{`
`179`		`- *current_p = '\n';`
	`165`	`+ *current_p = LIT_CHAR_LF;`
`180`	`166`	`break;`
`181`	`167`	`}`
`182`		`- case 'r':`
	`168`	`+ case LIT_CHAR_LOWERCASE_R:`
`183`	`169`	`{`
`184`		`- *current_p = '\r';`
	`170`	`+ *current_p = LIT_CHAR_CR;`
`185`	`171`	`break;`
`186`	`172`	`}`
`187`		`- case 't':`
	`173`	`+ case LIT_CHAR_LOWERCASE_T:`
`188`	`174`	`{`
`189`		`- *current_p = '\t';`
	`175`	`+ *current_p = LIT_CHAR_TAB;`
`190`	`176`	`break;`
`191`	`177`	`}`
`192`		`- case 'u':`
	`178`	`+ case LIT_CHAR_LOWERCASE_U:`
`193`	`179`	`{`
`194`	`180`	`lit_code_point_t code_point;`
`195`	`181`
`@@ -277,32 +263,32 @@ ecma_builtin_json_parse_number (ecma_json_token_t token_p) /*< token argument`
`277`	`263`	`lit_utf8_byte_t *current_p = token_p->current_p;`
`278`	`264`	`lit_utf8_byte_t *start_p = current_p;`
`279`	`265`
`280`		`- if (*current_p == '-')`
	`266`	`+ if (*current_p == LIT_CHAR_MINUS)`
`281`	`267`	`{`
`282`	`268`	`current_p++;`
`283`	`269`	`}`
`284`	`270`
`285`		`- if (*current_p == '0')`
	`271`	`+ if (*current_p == LIT_CHAR_0)`
`286`	`272`	`{`
`287`	`273`	`current_p++;`
`288`		`- if (isdigit (*current_p))`
	`274`	`+ if (lit_char_is_decimal_digit (*current_p))`
`289`	`275`	`{`
`290`	`276`	`return;`
`291`	`277`	`}`
`292`	`278`	`}`
`293`		`- else if (isdigit (*current_p))`
	`279`	`+ else if (lit_char_is_decimal_digit (*current_p))`
`294`	`280`	`{`
`295`	`281`	`do`
`296`	`282`	`{`
`297`	`283`	`current_p++;`
`298`	`284`	`}`
`299`		`- while (isdigit (*current_p));`
	`285`	`+ while (lit_char_is_decimal_digit (*current_p));`
`300`	`286`	`}`
`301`	`287`
`302`		`- if (*current_p == '.')`
	`288`	`+ if (*current_p == LIT_CHAR_DOT)`
`303`	`289`	`{`
`304`	`290`	`current_p++;`
`305`		`- if (!isdigit (*current_p))`
	`291`	`+ if (!lit_char_is_decimal_digit (*current_p))`
`306`	`292`	`{`
`307`	`293`	`return;`
`308`	`294`	`}`
`@@ -311,18 +297,18 @@ ecma_builtin_json_parse_number (ecma_json_token_t token_p) /*< token argument`
`311`	`297`	`{`
`312`	`298`	`current_p++;`
`313`	`299`	`}`
`314`		`- while (isdigit (*current_p));`
	`300`	`+ while (lit_char_is_decimal_digit (*current_p));`
`315`	`301`	`}`
`316`	`302`
`317`		`- if (current_p == 'e' \|\| current_p == 'E')`
	`303`	`+ if (current_p == LIT_CHAR_LOWERCASE_E \|\| current_p == LIT_CHAR_UPPERCASE_E)`
`318`	`304`	`{`
`319`	`305`	`current_p++;`
`320`		`- if (current_p == '+' \|\| current_p == '-')`
	`306`	`+ if (current_p == LIT_CHAR_PLUS \|\| current_p == LIT_CHAR_MINUS)`
`321`	`307`	`{`
`322`	`308`	`current_p++;`
`323`	`309`	`}`
`324`	`310`
`325`		`- if (!isdigit (*current_p))`
	`311`	`+ if (!lit_char_is_decimal_digit (*current_p))`
`326`	`312`	`{`
`327`	`313`	`return;`
`328`	`314`	`}`
`@@ -331,7 +317,7 @@ ecma_builtin_json_parse_number (ecma_json_token_t token_p) /*< token argument`
`331`	`317`	`{`
`332`	`318`	`current_p++;`
`333`	`319`	`}`
`334`		`- while (isdigit (*current_p));`
	`320`	`+ while (lit_char_is_decimal_digit (*current_p));`
`335`	`321`	`}`
`336`	`322`	`token_p->type = number_token;`
`337`	`323`	`token_p->u.number = ecma_utf8_string_to_number (start_p, (lit_utf8_size_t) (current_p - start_p));`
`@@ -354,8 +340,8 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t token_p) /*< token argum`
`354`	`340`	`/*`
`355`	`341`	`* No need for end check since the string is zero terminated.`
`356`	`342`	`*/`
`357`		`- while (current_p == ' ' \|\| current_p == '\r'`
`358`		`- \|\| current_p == '\n' \|\| current_p == '\t')`
	`343`	`+ while (current_p == LIT_CHAR_SP \|\| current_p == LIT_CHAR_CR`
	`344`	`+ \|\| current_p == LIT_CHAR_LF \|\| current_p == LIT_CHAR_TAB)`
`359`	`345`	`{`
`360`	`346`	`current_p++;`
`361`	`347`	`}`
`@@ -368,43 +354,43 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t token_p) /*< token argum`
`368`	`354`
`369`	`355`	`switch (*current_p)`
`370`	`356`	`{`
`371`		`- case '{':`
	`357`	`+ case LIT_CHAR_LEFT_BRACE:`
`372`	`358`	`{`
`373`	`359`	`token_p->type = left_brace_token;`
`374`	`360`	`token_p->current_p = current_p + 1;`
`375`	`361`	`return;`
`376`	`362`	`}`
`377`		`- case '}':`
	`363`	`+ case LIT_CHAR_RIGHT_BRACE:`
`378`	`364`	`{`
`379`	`365`	`token_p->type = right_brace_token;`
`380`	`366`	`token_p->current_p = current_p + 1;`
`381`	`367`	`return;`
`382`	`368`	`}`
`383`		`- case '[':`
	`369`	`+ case LIT_CHAR_LEFT_SQUARE:`
`384`	`370`	`{`
`385`	`371`	`token_p->type = left_square_token;`
`386`	`372`	`token_p->current_p = current_p + 1;`
`387`	`373`	`return;`
`388`	`374`	`}`
`389`		`- case ',':`
	`375`	`+ case LIT_CHAR_COMMA:`
`390`	`376`	`{`
`391`	`377`	`token_p->type = comma_token;`
`392`	`378`	`token_p->current_p = current_p + 1;`
`393`	`379`	`return;`
`394`	`380`	`}`
`395`		`- case ':':`
	`381`	`+ case LIT_CHAR_COLON:`
`396`	`382`	`{`
`397`	`383`	`token_p->type = colon_token;`
`398`	`384`	`token_p->current_p = current_p + 1;`
`399`	`385`	`return;`
`400`	`386`	`}`
`401`		`- case '"':`
	`387`	`+ case LIT_CHAR_DOUBLE_QUOTE:`
`402`	`388`	`{`
`403`	`389`	`token_p->current_p = current_p + 1;`
`404`	`390`	`ecma_builtin_json_parse_string (token_p);`
`405`	`391`	`return;`
`406`	`392`	`}`
`407`		`- case 'n':`
	`393`	`+ case LIT_CHAR_LOWERCASE_N:`
`408`	`394`	`{`
`409`	`395`	`if (ecma_builtin_json_check_id (current_p, "null"))`
`410`	`396`	`{`
`@@ -414,7 +400,7 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t token_p) /*< token argum`
`414`	`400`	`}`
`415`	`401`	`break;`
`416`	`402`	`}`
`417`		`- case 't':`
	`403`	`+ case LIT_CHAR_LOWERCASE_T:`
`418`	`404`	`{`
`419`	`405`	`if (ecma_builtin_json_check_id (current_p, "true"))`
`420`	`406`	`{`
`@@ -424,7 +410,7 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t token_p) /*< token argum`
`424`	`410`	`}`
`425`	`411`	`break;`
`426`	`412`	`}`
`427`		`- case 'f':`
	`413`	`+ case LIT_CHAR_LOWERCASE_F:`
`428`	`414`	`{`
`429`	`415`	`if (ecma_builtin_json_check_id (current_p, "false"))`
`430`	`416`	`{`
`@@ -436,7 +422,7 @@ ecma_builtin_json_parse_next_token (ecma_json_token_t token_p) /*< token argum`
`436`	`422`	`}`
`437`	`423`	`default:`
`438`	`424`	`{`
`439`		`- if (current_p == '-' \|\| isdigit (current_p))`
	`425`	`+ if (current_p == LIT_CHAR_MINUS \|\| lit_char_is_decimal_digit (current_p))`
`440`	`426`	`{`
`441`	`427`	`token_p->current_p = current_p;`
`442`	`428`	`ecma_builtin_json_parse_number (token_p);`
`@@ -462,15 +448,15 @@ ecma_builtin_json_check_right_square_token (ecma_json_token_t token_p) /*< tok`
`462`	`448`	`/*`
`463`	`449`	`* No need for end check since the string is zero terminated.`
`464`	`450`	`*/`
`465`		`- while (current_p == ' ' \|\| current_p == '\r'`
`466`		`- \|\| current_p == '\n' \|\| current_p == '\t')`
	`451`	`+ while (current_p == LIT_CHAR_SP \|\| current_p == LIT_CHAR_CR`
	`452`	`+ \|\| current_p == LIT_CHAR_LF \|\| current_p == LIT_CHAR_TAB)`
`467`	`453`	`{`
`468`	`454`	`current_p++;`
`469`	`455`	`}`
`470`	`456`
`471`	`457`	`token_p->current_p = current_p;`
`472`	`458`
`473`		`- if (*current_p == ']')`
	`459`	`+ if (*current_p == LIT_CHAR_RIGHT_SQUARE)`
`474`	`460`	`{`
`475`	`461`	`token_p->current_p = current_p + 1;`
`476`	`462`	`return true;`
`@@ -1107,7 +1093,7 @@ ecma_builtin_json_stringify (ecma_value_t this_arg __attr_unused___, /**< 'this'`
`1107`	`1093`
`1108`	`1094`	`for (int32_t i = 0; i < space; i++)`
`1109`	`1095`	`{`
`1110`		`- space_buff[i] = ' ';`
	`1096`	`+ space_buff[i] = LIT_CHAR_SP;`
`1111`	`1097`	`}`
`1112`	`1098`
`1113`	`1099`	`context_p.gap_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) space_buff, (lit_utf8_size_t) space);`
`@@ -1228,7 +1214,7 @@ ecma_builtin_json_quote (ecma_string_t string_p) /*< string that should be quo`
`1228`	`1214`	`lit_utf8_byte_t c = zt_string_buff[i];`
`1229`	`1215`
`1230`	`1216`	`/* 2.a */`
`1231`		`- if (c == '\\' \|\| c == '\"')`
	`1217`	`+ if (c == LIT_CHAR_BACKSLASH \|\| c == LIT_CHAR_DOUBLE_QUOTE)`
`1232`	`1218`	`{`
`1233`	`1219`	`ecma_string_t *backslash_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_BACKSLASH_CHAR);`
`1234`	`1220`
`@@ -1247,7 +1233,8 @@ ecma_builtin_json_quote (ecma_string_t string_p) /*< string that should be quo`
`1247`	`1233`	`product_str_p = tmp_str_p;`
`1248`	`1234`	`}`
`1249`	`1235`	`/* 2.b */`
`1250`		`- else if (c == '\b' \|\| c == '\f' \|\| c == '\n' \|\| c == '\r' \|\| c == '\t')`
	`1236`	`+ else if (c == LIT_CHAR_BS \|\| c == LIT_CHAR_FF \|\| c == LIT_CHAR_LF`
	`1237`	`+ \|\| c == LIT_CHAR_CR \|\| c == LIT_CHAR_TAB)`
`1251`	`1238`	`{`
`1252`	`1239`	`ecma_string_t *backslash_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_BACKSLASH_CHAR);`
`1253`	`1240`
`@@ -1258,33 +1245,33 @@ ecma_builtin_json_quote (ecma_string_t string_p) /*< string that should be quo`
`1258`	`1245`	`product_str_p = tmp_str_p;`
`1259`	`1246`
`1260`	`1247`	`/* 2.b.ii */`
`1261`		`- lit_utf8_byte_t abbrev = ' ';`
	`1248`	`+ lit_utf8_byte_t abbrev = LIT_CHAR_SP;`
`1262`	`1249`
`1263`	`1250`	`switch (c)`
`1264`	`1251`	`{`
`1265`		`- case '\b':`
	`1252`	`+ case LIT_CHAR_BS:`
`1266`	`1253`	`{`
`1267`		`- abbrev = 'b';`
	`1254`	`+ abbrev = LIT_CHAR_LOWERCASE_B;`
`1268`	`1255`	`break;`
`1269`	`1256`	`}`
`1270`		`- case '\f':`
	`1257`	`+ case LIT_CHAR_FF:`
`1271`	`1258`	`{`
`1272`		`- abbrev = 'f';`
	`1259`	`+ abbrev = LIT_CHAR_LOWERCASE_F;`
`1273`	`1260`	`break;`
`1274`	`1261`	`}`
`1275`		`- case '\n':`
	`1262`	`+ case LIT_CHAR_LF:`
`1276`	`1263`	`{`
`1277`		`- abbrev = 'n';`
	`1264`	`+ abbrev = LIT_CHAR_LOWERCASE_N;`
`1278`	`1265`	`break;`
`1279`	`1266`	`}`
`1280`		`- case '\r':`
	`1267`	`+ case LIT_CHAR_CR:`
`1281`	`1268`	`{`
`1282`		`- abbrev = 'r';`
	`1269`	`+ abbrev = LIT_CHAR_LOWERCASE_R;`
`1283`	`1270`	`break;`
`1284`	`1271`	`}`
`1285`		`- case '\t':`
	`1272`	`+ case LIT_CHAR_TAB:`
`1286`	`1273`	`{`
`1287`		`- abbrev = 't';`
	`1274`	`+ abbrev = LIT_CHAR_LOWERCASE_T;`
`1288`	`1275`	`break;`
`1289`	`1276`	`}`
`1290`	`1277`	`}`
`@@ -1309,7 +1296,7 @@ ecma_builtin_json_quote (ecma_string_t string_p) /*< string that should be quo`
`1309`	`1296`	`product_str_p = tmp_str_p;`
`1310`	`1297`
`1311`	`1298`	`/* 2.c.ii */`
`1312`		`- lit_utf8_byte_t u_ch = 'u';`
	`1299`	`+ lit_utf8_byte_t u_ch = LIT_CHAR_LOWERCASE_U;`
`1313`	`1300`	`ecma_string_t *u_ch_str_p = ecma_new_ecma_string_from_utf8 (&u_ch, 1);`
`1314`	`1301`
`1315`	`1302`	`tmp_str_p = ecma_concat_ecma_strings (product_str_p, u_ch_str_p);`