Handle casts to function pointers

Author: spievniev

README.md.in

@@ -86,11 +86,6 @@ macro |  description | default
 
 ## Limitations
 
-- Casting to a function pointer:
-    ```c
-    uprintf("%S\n", (void (*)(void)) whatever);
-    ```
-
 - Incorrect type deduction when printing variables that get shadowed *later* in the same scope.
     ```c
     char var = 'c';

test.sh

@@ -135,7 +135,7 @@ if [ $ret -ne 0 ]; then
     exit 1
 fi
 
-if [ ! -r $baseline ]; then
+if [ ! -r $baseline ] || [ ! -s $baseline ]; then
     echo -e "$YELLOW[WARNING]$RESET There is no $test baseline."
     echo -e "$GREEN[TEST PASSED]$RESET $test_id: ?";
     exit 0

tests/baselines/function_casts.out

@@ -0,0 +1,8 @@
+1
+2
+3
+4
+5
+6
+7
+8

tests/function_casts.c

@@ -0,0 +1,32 @@
+#include "uprintf.h"
+
+int *i_fun(int i) {
+    static int j;
+    j = i;
+    return &j;
+}
+
+int *(*j_fun(char c))(int i) {
+    (void) c;
+    return i_fun;
+}
+
+int *(*(**k_fun(void))(char c))(int i) {
+    static int *(*(*t)(char) )(int) = j_fun;
+    return &t;
+}
+
+int main(void) {
+    uprintf("%s\n", ((int *(*) (int) ) i_fun)(1));
+    uprintf("%s\n", ((int *((*) )(int) ) i_fun)(2));
+    uprintf("%s\n", ((int *((*) (int) )) i_fun)(3));
+
+    uprintf("%s\n", (((int *((*(*) (char) )(int) )) j_fun)('a')(4)));
+    uprintf("%s\n", (((int *((*((*) (char) ))(int) )) j_fun)('b')(5)));
+    uprintf("%s\n", (((int *((*(((*) (char) )))(int) )) j_fun)('c')(6)));
+
+    uprintf("%s\n", (*((int *(*(**(*) (void) )(char) )(int) ) k_fun)())('d')(7));
+    uprintf("%s\n", (*((int *(*((**(*) (void) )(char) ))(int) ) k_fun)())('e')(8));
+
+    return _upf_test_status;
+}

uprintf.h

@@ -2516,6 +2516,44 @@ static _upf_type *_upf_parse(_upf_parse_precedence precedence);
 
 static _upf_type *_upf_parse_expression(void) { return _upf_parse(_UPF_PREC_ASSIGNMENT); }
 
+static int _upf_parse_abstract_declarator(_upf_type **function_type, _upf_type ***function_return_type) {
+    _UPF_ASSERT(function_type != NULL && function_return_type != NULL);
+
+    int pointers = 0;
+    while (_upf_match_token(_UPF_TOK_STAR)) {
+        pointers++;
+        while (_upf_match_token(_UPF_TOK_TYPE_QUALIFIER)) continue;
+    }
+
+    if (!_upf_match_token(_UPF_TOK_OPEN_PAREN)) return pointers;
+    int sub_pointers = _upf_parse_abstract_declarator(function_type, function_return_type);
+    _upf_expect_token(_UPF_TOK_CLOSE_PAREN);
+
+    if (!_upf_match_token(_UPF_TOK_OPEN_PAREN)) return pointers + sub_pointers;
+    _upf_consume_parens(_UPF_TOK_OPEN_PAREN, _UPF_TOK_CLOSE_PAREN);
+
+    _UPF_ASSERT(sub_pointers > 0);
+    sub_pointers--;
+
+    _upf_type *current_function_type = _upf_add_type(NULL, (_upf_type) {
+                                                               .kind = _UPF_TK_FUNCTION,
+                                                               .size = sizeof(void *),
+                                                           });
+    _upf_type **current_function_return_type = &current_function_type->as.function.return_type;
+
+    while (sub_pointers-- > 0) current_function_type = _upf_get_pointer_to_type(current_function_type);
+
+    if (*function_type == NULL) {
+        *function_type = current_function_type;
+    } else {
+        _UPF_ASSERT(*function_return_type != NULL);
+        **function_return_type = current_function_type;
+    }
+
+    *function_return_type = current_function_return_type;
+    return pointers;
+}
+
 static _upf_type *_upf_parse_typename(void) {
     const char *type_specifiers[4];
     size_t type_specifiers_idx = 0;
@@ -2560,29 +2598,9 @@ static _upf_type *_upf_parse_typename(void) {
         }
     }
 
-    int pointer = 0;
-    while (_upf_match_token(_UPF_TOK_STAR)) {
-        pointer++;
-        while (_upf_match_token(_UPF_TOK_TYPE_QUALIFIER)) continue;
-    }
-
-    bool parsed_declarator = false;
-    while (!parsed_declarator) {
-        switch (_upf_peek_token().kind) {
-            case _UPF_TOK_OPEN_PAREN:
-                // TODO:
-                _UPF_ERROR("TODO");
-                break;
-            case _UPF_TOK_OPEN_BRACKET:
-                _upf_consume_token();
-                while (!_upf_match_token(_UPF_TOK_CLOSE_BRACKET)) _upf_consume_token();
-                pointer++;
-                break;
-            default:
-                parsed_declarator = true;
-                break;
-        }
-    }
+    _upf_type *function_type = NULL;
+    _upf_type **function_return_type = NULL;
+    int pointers = _upf_parse_abstract_declarator(&function_type, &function_return_type);
 
     _upf_type *type_ptr;
     if (identifier != NULL) {
@@ -2670,9 +2688,14 @@ static _upf_type *_upf_parse_typename(void) {
     }
 
     _UPF_ASSERT(type_ptr != NULL);
-    while (pointer > 0) {
+    while (pointers > 0) {
         type_ptr = _upf_get_pointer_to_type(type_ptr);
-        pointer--;
+        pointers--;
+    }
+
+    if (function_type != NULL) {
+        *function_return_type = type_ptr;
+        type_ptr = function_type;
     }
 
     return type_ptr;