Support syntax error feedback in parser.

Now, parser correctly finishes parse procedure if syntax of source code is incorrect (syntax correctness is indicated using return value):
 - parser-internal memory management is performed using jsp_mm_alloc / jsp_mm_free;
 - upon detection of incorrect syntax, all parser-allocated memory regions are deallocated using jsp_mm_free_all and parse finishes with corresponding return value.

JerryScript-DCO-1.0-Signed-off-by: Ruben Ayrapetyan [email protected]

Author: ruben-ayrapetyan

jerry-core/jerry.h

@@ -49,7 +49,6 @@ typedef enum
 {
   ERR_OUT_OF_MEMORY = 10,
   ERR_SYSCALL = 11,
-  ERR_PARSER = 12,
   ERR_UNIMPLEMENTED_CASE = 118,
   ERR_FAILED_INTERNAL_ASSERTION = 120
 } jerry_fatal_code_t;

jerry-core/jrt/jrt-fatals.cpp

@@ -47,11 +47,6 @@ jerry_fatal (jerry_fatal_code_t code) /**< status code */
       /* print nothing as it may invoke syscall recursively */
       break;
     }
-    case ERR_PARSER:
-    {
-      printf ("ERR_PARSER\n");
-      break;
-    }
     case ERR_UNIMPLEMENTED_CASE:
     {
       printf ("ERR_UNIMPLEMENTED_CASE\n");

jerry-core/jrt/jrt-libc-includes.h

@@ -17,6 +17,8 @@
 #define JRT_LIBC_INCLUDES_H
 
 #include <ctype.h>
+#include <setjmp.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>

jerry-core/parser/js/collections/array-list.cpp

@@ -14,8 +14,8 @@
  */
 
 #include "array-list.h"
-#include "mem-heap.h"
 #include "jrt-libc-includes.h"
+#include "jsp-mm.h"
 
 typedef struct
 {
@@ -44,14 +44,14 @@ array_list_append (array_list al, void *element)
   array_list_header *h = extract_header (al);
   if ((h->len + 1) * h->element_size + sizeof (array_list_header) > h->size)
   {
-    size_t size = mem_heap_recommend_allocation_size (h->size + h->element_size);
+    size_t size = jsp_mm_recommend_size (h->size + h->element_size);
     JERRY_ASSERT (size > h->size);
 
-    uint8_t* new_block_p = (uint8_t*) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_SHORT_TERM);
+    uint8_t *new_block_p = (uint8_t *) jsp_mm_alloc (size);
     memcpy (new_block_p, h, h->size);
     memset (new_block_p + h->size, 0, size - h->size);
 
-    mem_heap_free_block ((uint8_t *) h);
+    jsp_mm_free (h);
 
     h = (array_list_header *) new_block_p;
     h->size = size;
@@ -111,8 +111,8 @@ array_list_set_last_element (array_list al, size_t index, void *elem)
 array_list
 array_list_init (uint8_t element_size)
 {
-  size_t size = mem_heap_recommend_allocation_size (sizeof (array_list_header));
-  array_list_header *header = (array_list_header *) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_SHORT_TERM);
+  size_t size = jsp_mm_recommend_size (sizeof (array_list_header));
+  array_list_header *header = (array_list_header *) jsp_mm_alloc (size);
   memset (header, 0, size);
   header->element_size = element_size;
   header->len = 0;
@@ -131,5 +131,5 @@ void
 array_list_free (array_list al)
 {
   array_list_header *h = extract_header (al);
-  mem_heap_free_block ((uint8_t *) h);
+  jsp_mm_free (h);
 }

jerry-core/parser/js/collections/hash-table.cpp

@@ -13,10 +13,10 @@
  * limitations under the License.
  */
 
-#include "hash-table.h"
 #include "array-list.h"
-#include "mem-heap.h"
+#include "hash-table.h"
 #include "jrt-libc-includes.h"
+#include "jsp-mm.h"
 
 typedef struct
 {
@@ -25,7 +25,6 @@ typedef struct
   uint16_t size;
   uint8_t key_size;
   uint8_t value_size;
-  mem_heap_alloc_term_t alloc_term;
 } hash_table_int;
 
 static hash_table_int *
@@ -65,12 +64,12 @@ hash_table_insert (hash_table ht, void *key, void *value)
   {
     list = array_list_init (bucket_size (hti));
   }
-  uint8_t *bucket = (uint8_t*) mem_heap_alloc_block (bucket_size (hti), hti->alloc_term);
+  uint8_t *bucket = (uint8_t *) jsp_mm_alloc (bucket_size (hti));
   memcpy (bucket, key, hti->key_size);
   memcpy (bucket + hti->key_size, value, hti->value_size);
   list = array_list_append (list, bucket);
   hti->data[index] = list;
-  mem_heap_free_block (bucket);
+  jsp_mm_free (bucket);
 }
 
 void *
@@ -98,15 +97,14 @@ hash_table_lookup (hash_table ht, void *key)
 
 hash_table
 hash_table_init (uint8_t key_size, uint8_t value_size, uint16_t size,
-                 uint16_t (*hash) (void *), mem_heap_alloc_term_t alloc_term)
+                 uint16_t (*hash) (void *))
 {
-  hash_table_int *res = (hash_table_int *) mem_heap_alloc_block (sizeof (hash_table_int), alloc_term);
+  hash_table_int *res = (hash_table_int *) jsp_mm_alloc (sizeof (hash_table_int));
   memset (res, 0, sizeof (hash_table_int));
   res->key_size = key_size;
   res->value_size = value_size;
   res->size = size;
-  res->alloc_term = alloc_term;
-  res->data = (array_list *) mem_heap_alloc_block (size * sizeof (array_list), alloc_term);
+  res->data = (array_list *) jsp_mm_alloc (size * sizeof (array_list));
   memset (res->data, 0, size * sizeof (array_list));
   res->hash = hash;
   return res;
@@ -125,6 +123,6 @@ hash_table_free (hash_table ht)
       set_list (h, i, null_list);
     }
   }
-  mem_heap_free_block ((uint8_t *) h->data);
-  mem_heap_free_block ((uint8_t *) h);
+  jsp_mm_free (h->data);
+  jsp_mm_free (h);
 }

jerry-core/parser/js/collections/hash-table.h

@@ -30,7 +30,7 @@
 typedef void* hash_table;
 #define null_hash NULL
 
-hash_table hash_table_init (uint8_t, uint8_t, uint16_t, uint16_t (*hash) (void *), mem_heap_alloc_term_t);
+hash_table hash_table_init (uint8_t, uint8_t, uint16_t, uint16_t (*hash) (void *));
 void hash_table_free (hash_table);
 void hash_table_insert (hash_table, void *, void *);
 void *hash_table_lookup (hash_table, void *);

jerry-core/parser/js/collections/linked-list.cpp

@@ -13,9 +13,9 @@
  * limitations under the License.
  */
 
-#include "linked-list.h"
 #include "jrt-libc-includes.h"
-#include "mem-heap.h"
+#include "jsp-mm.h"
+#include "linked-list.h"
 
 typedef struct linked_list_header
 {
@@ -31,14 +31,14 @@ do { \
 
 static size_t linked_list_block_size (uint16_t element_size)
 {
-  return mem_heap_recommend_allocation_size (sizeof (linked_list_header) + element_size) - sizeof (linked_list_header);
+  return jsp_mm_recommend_size (sizeof (linked_list_header) + element_size) - sizeof (linked_list_header);
 }
 
 linked_list
 linked_list_init (uint16_t element_size)
 {
   size_t size = sizeof (linked_list_header) + linked_list_block_size (element_size);
-  linked_list list = (linked_list) mem_heap_alloc_block (size, MEM_HEAP_ALLOC_SHORT_TERM);
+  linked_list list = (linked_list) jsp_mm_alloc (size);
   if (list == null_list)
   {
     printf ("Out of memory");
@@ -60,7 +60,7 @@ linked_list_free (linked_list list)
   {
     linked_list_free ((linked_list) header->next);
   }
-  mem_heap_free_block (list);
+  jsp_mm_free (list);
 }
 
 void *

jerry-core/parser/js/lexer.cpp

@@ -13,11 +13,11 @@
  * limitations under the License.
  */
 
-#include "mem-allocator.h"
+#include "ecma-helpers.h"
 #include "jrt-libc-includes.h"
+#include "jsp-mm.h"
 #include "lexer.h"
 #include "syntax-errors.h"
-#include "ecma-helpers.h"
 
 static token saved_token, prev_token, sent_token, empty_token;
 
@@ -474,9 +474,7 @@ convert_string_to_token_transform_escape_seq (token_type tok_type, /**< type of
     JERRY_ASSERT (source_str_p != NULL);
   }
 
-  MEM_DEFINE_LOCAL_ARRAY (str_buf_p,
-                          source_str_size,
-                          ecma_char_t);
+  ecma_char_t *str_buf_p = (ecma_char_t*) jsp_mm_alloc (source_str_size * sizeof (ecma_char_t));
 
   const char *source_str_iter_p = source_str_p;
   ecma_char_t *str_buf_iter_p = str_buf_p;
@@ -632,7 +630,7 @@ convert_string_to_token_transform_escape_seq (token_type tok_type, /**< type of
     PARSE_ERROR ("Malformed escape sequence", source_str_p - buffer_start);
   }
 
-  MEM_FINALIZE_LOCAL_ARRAY (str_buf_p);
+  jsp_mm_free (str_buf_p);
 
   return ret;
 } /* convert_string_to_token_transform_escape_seq */
@@ -860,13 +858,12 @@ parse_number (void)
   tok_length = (size_t) (buffer - token_start);;
   if (is_fp || is_exp)
   {
-    ecma_char_t *temp = (ecma_char_t*) mem_heap_alloc_block ((size_t) (tok_length + 1),
-                                                             MEM_HEAP_ALLOC_SHORT_TERM);
+    ecma_char_t *temp = (ecma_char_t*) jsp_mm_alloc ((size_t) (tok_length + 1) * sizeof (ecma_char_t));
     strncpy ((char *) temp, token_start, (size_t) (tok_length));
     temp[tok_length] = '\0';
     ecma_number_t res = ecma_zt_string_to_number (temp);
     JERRY_ASSERT (!ecma_number_is_nan (res));
-    mem_heap_free_block (temp);
+    jsp_mm_free (temp);
     known_token = convert_seen_num_to_token (res);
     token_start = NULL;
     return known_token;
@@ -1467,28 +1464,22 @@ lexer_are_tokens_with_same_identifier (token id1, /**< identifier token (TOK_NAM
 } /* lexer_are_tokens_with_same_identifier */
 
 /**
- * Initialize lexer to start parsing of a new source
+ * Intitialize lexer
  */
 void
-lexer_init_source (const char *source, /**< script source */
-                   size_t source_size) /**< script source size in bytes */
+lexer_init (const char *source, /**< script source */
+            size_t source_size /**< script source size in bytes */,
+            bool show_opcodes) /**< flag indicating if to dump opcodes */
 {
+  empty_token.type = TOK_EMPTY;
+  empty_token.uid = 0;
+  empty_token.loc = 0;
+
   saved_token = prev_token = sent_token = empty_token;
 
   buffer_size = source_size;
   lexer_set_source (source);
   lexer_set_strict_mode (false);
-} /* lexer_init_source */
-
-/**
- * Intitialize lexer
- */
-void
-lexer_init (bool show_opcodes) /**< flag indicating if to dump opcodes */
-{
-  empty_token.type = TOK_EMPTY;
-  empty_token.uid = 0;
-  empty_token.loc = 0;
 
 #ifndef JERRY_NDEBUG
   allow_dump_lines = show_opcodes;
@@ -1497,8 +1488,3 @@ lexer_init (bool show_opcodes) /**< flag indicating if to dump opcodes */
   allow_dump_lines = false;
 #endif /* JERRY_NDEBUG */
 } /* lexer_init */
-
-void
-lexer_free (void)
-{
-}

jerry-core/parser/js/lexer.h

@@ -169,9 +169,7 @@ typedef struct
  */
 #define TOKEN_EMPTY_INITIALIZER {0, TOK_EMPTY, 0}
 
-void lexer_init (bool);
-void lexer_init_source (const char *, size_t);
-void lexer_free (void);
+void lexer_init (const char *, size_t, bool);
 
 token lexer_next_token (void);
 void lexer_save_token (token);