Rewrite error diagnostic mechanism

Author: ChAoSUnItY

src/globals.c

@@ -1652,24 +1652,40 @@ void fatal(char *msg)
     abort();
 }
 
+/* Reports error and prints occurred position context,
+ * if the given location is NULL or source file is missing,
+ * then fallbacks to fatal(char *).
+ */
 void error_at(char *msg, source_location_t *loc)
 {
-    int offset, start_idx, i = 0, len = loc->len, pos = loc->pos;
+    int offset, start_idx, i = 0, len, pos;
     char diagnostic[MAX_LINE_LEN];
+
+    if (!loc)
+        fatal(msg);
+
+    len = loc->len;
+    pos = loc->pos;
+
     strbuf_t *src = hashmap_get(SRC_FILE_MAP, loc->filename);
 
+    if (!src)
+        fatal(msg);
+
     if (len < 1)
         len = 1;
 
     printf("%s:%d:%d: [Error]: %s\n", loc->filename, loc->line, loc->column,
            msg);
     printf("%6d |  ", loc->line);
 
+    /* Finds line's start position */
     for (offset = pos; offset >= 0 && src->elements[offset] != '\n'; offset--)
         ;
 
     start_idx = offset + 1;
 
+    /* Copies whole line to diagnostic buffer */
     for (offset = start_idx;
          offset < src->capacity && src->elements[offset] != '\n' &&
          src->elements[offset] != '\0';

src/lexer.c

@@ -202,7 +202,7 @@ token_t *new_token(token_kind_t kind, source_location_t *loc, int len)
     return token;
 }
 
-token_t *lex_token(strbuf_t *buf, source_location_t *loc, token_t *prev)
+token_t *lex_token(strbuf_t *buf, source_location_t *loc)
 {
     token_t *token;
     char token_buffer[MAX_TOKEN_LEN], ch = peek_char(buf, 0);
@@ -274,7 +274,7 @@ token_t *lex_token(strbuf_t *buf, source_location_t *loc, token_t *prev)
                         pos++;
                         loc->column += 2;
                         buf->size = pos;
-                        return lex_token(buf, loc, prev);
+                        return lex_token(buf, loc);
                     }
                 }
 
@@ -297,7 +297,7 @@ token_t *lex_token(strbuf_t *buf, source_location_t *loc, token_t *prev)
             } while (ch && !is_newline(ch));
             loc->column += pos - buf->size + 1;
             buf->size = pos;
-            return lex_token(buf, loc, prev);
+            return lex_token(buf, loc);
         }
 
         if (ch == '=') {
@@ -920,7 +920,8 @@ token_stream_t *lex_token_by_file(char *filename)
     /* FIXME: We should normalize filename first to make cache works as expected
      */
 
-    token_t *head = NULL, *tail = NULL, *cur = NULL, *prev = NULL;
+    token_t head;
+    token_t *cur = &head;
     token_stream_t *tks;
     /* initialie source location with the following configuration:
      * pos is at 0,
@@ -942,47 +943,35 @@ token_stream_t *lex_token_by_file(char *filename)
     buf->size = 0;
 
     while (buf->size < buf->capacity) {
-        cur = lex_token(buf, &loc, prev);
-
-        if (cur->kind != T_whitespace && cur->kind != T_tab &&
-            cur->kind != T_eof)
-            prev = cur;
-
-        /* Append token to token stream */
-        if (!head) {
-            /* Token stream unintialized  */
-            head = cur;
-            tail = head;
-        }
-
-        tail->next = cur;
-        tail = cur;
+        cur->next = lex_token(buf, &loc);
+        cur = cur->next;
 
         if (cur->kind == T_eof)
             break;
     }
 
-    if (!head) {
-        head = arena_calloc(TOKEN_ARENA, 1, sizeof(token_t));
-        head->kind = T_eof;
-        memcpy(&head->location, &loc, sizeof(source_location_t));
-        tail = head;
+    if (!head.next) {
+        head.next = arena_calloc(TOKEN_ARENA, 1, sizeof(token_t));
+        head.next->kind = T_eof;
+        memcpy(&head.next->location, &loc, sizeof(source_location_t));
+        cur = head.next;
     }
 
-    if (tail->kind != T_eof)
+    if (cur->kind != T_eof)
         error_at("Internal error, expected eof at the end of file",
-                 &tail->location);
+                 &cur->location);
 
     tks = malloc(sizeof(token_stream_t));
-    tks->head = head;
-    tks->tail = tail;
+    tks->head = head.next;
+    tks->tail = cur;
     hashmap_put(TOKEN_CACHE, filename, tks);
     return tks;
 }
 
 token_stream_t *include_libc()
 {
-    token_t *head = NULL, *tail = NULL, *cur = NULL, *prev = NULL;
+    token_t head;
+    token_t *cur = &head, *tk;
     token_stream_t *tks;
     char *filename = "lib/c.c";
     strbuf_t *buf = LIBC_SRC;
@@ -1000,41 +989,29 @@ token_stream_t *include_libc()
     buf->size = 0;
 
     while (buf->size < buf->capacity) {
-        cur = lex_token(buf, &loc, prev);
-
-        if (cur->kind != T_whitespace && cur->kind != T_tab &&
-            cur->kind != T_eof)
-            prev = cur;
-
-        /* Append token to token stream */
-        if (!head) {
-            /* Token stream unintialized  */
-            head = cur;
-            tail = head;
-        }
-
-        tail->next = cur;
-        tail = cur;
+        tk = lex_token(buf, &loc);
 
-        if (cur->kind == T_eof)
+        /* Early break to discard eof token, so later
+         * we can concat libc token stream with actual
+         * input file's token stream.
+         */
+        if (tk->kind == T_eof)
             break;
+
+        cur->next = tk;
+        cur = cur->next;
     }
 
-    if (!head)
+    if (!head.next)
         fatal("Unable to include libc");
 
-    if (tail->kind != T_eof)
+    if (tk->kind != T_eof)
         error_at("Internal error, expected eof at the end of file",
-                 &tail->location);
-
-    /* Discard eof so later input file's token stream can join at correct
-     * position */
-    prev->next = NULL;
-    tail = prev;
+                 &cur->location);
 
     tks = malloc(sizeof(token_stream_t));
-    tks->head = head;
-    tks->tail = tail;
+    tks->head = head.next;
+    tks->tail = cur;
     hashmap_put(TOKEN_CACHE, filename, tks);
     return tks;
 }
@@ -1051,6 +1028,25 @@ void skip_unused_token(void)
     }
 }
 
+/* Fetches current token's location. */
+source_location_t *cur_token_loc()
+{
+    return &cur_token->location;
+}
+
+/* Finds next token's location, whitespace, tab, and newline tokens are skipped,
+ * if current token is eof, then returns eof token's location instead.
+ */
+source_location_t *next_token_loc()
+{
+    skip_unused_token();
+
+    if (cur_token->kind == T_eof)
+        return &cur_token->location;
+
+    return &cur_token->next->location;
+}
+
 /* Lex next token with aliasing enabled */
 token_kind_t lex_next(void)
 {
@@ -1063,9 +1059,7 @@ token_kind_t lex_next(void)
     return cur_token->kind;
 }
 
-/* Accepts next token if token types are matched. To disable aliasing on next
- * token, use 'lex_accept_internal'.
- */
+/* Accepts next token if token types are matched. */
 bool lex_accept(token_kind_t kind)
 {
     skip_unused_token();
@@ -1092,7 +1086,7 @@ bool lex_peek(token_kind_t kind, char *value)
 }
 
 /* Strictly match next token with given token type and copy token's literal to
- * value. To disable aliasing on next token, use 'lex_ident_internal'.
+ * value.
  */
 void lex_ident(token_kind_t token, char *value)
 {
@@ -1107,8 +1101,7 @@ void lex_ident(token_kind_t token, char *value)
     error_at("Unexpected token", &tk->location);
 }
 
-/* Strictly match next token with given token type. To disable aliasing on next
- * token, use 'lex_expect_internal'.
+/* Strictly match next token with given token type.
  */
 void lex_expect(token_kind_t token)
 {