fmt

qic.c

@@ -1673,16 +1673,15 @@ list_t *MACROS;
   ((*pos) + p < tokens->length && \
    ((token_t *)tokens->data[(*pos) + p])->tag == T_##tk)
 #define MATCH(tk) ((*pos < tokens->length && ((token_t *)tokens->data[*pos])->tag == T_##tk) && ++(*pos))
-#define PARSE_ERROR(fmt, ...)                                                  \
-  {                                                                            \
-    format_error(                                                              \
-        GETFNAME(                                                              \
-            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi),  \
-        GETSRC(                                                                \
-            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi),  \
-        ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos, fmt, \
-        ##__VA_ARGS__);                                                        \
-    exit(1);                                                                   \
+#define PARSE_ERROR(fmt, ...)                                                                  \
+  {                                                                                            \
+    format_error(                                                                              \
+        GETFNAME(                                                                              \
+            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi),                  \
+        GETSRC(                                                                                \
+            ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->fi),                  \
+        ((token_t *)tokens->data[(*pos) > 0 ? (*pos) - 1 : (*pos)])->pos, fmt, ##__VA_ARGS__); \
+    exit(1);                                                                                   \
   }
 #define EXPECT(tk, s)                                                                             \
   {                                                                                               \
@@ -3791,26 +3790,23 @@ node_t *parse(char *source)
         },                                                            \
         true);                                                        \
   }
-#define COMPILE_ERROR(fmt, ...)                                                        \
+#define COMPILE_ERROR(fmt, ...)                                                                    \
+  {                                                                                                \
+    if (MACROCALLS->length)                                                                        \
+    {                                                                                              \
+      format_error(GETFNAME(((node_t *)MACROCALLS->data[MACROCALLS->length - 1])->fi),             \
+                   GETSRC(((node_t *)MACROCALLS->data[MACROCALLS->length - 1])->fi),               \
+                   ((node_t *)MACROCALLS->data[MACROCALLS->length - 1])->pos, fmt, ##__VA_ARGS__); \
+      format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos,                                \
+                   "after the expansion of macro:");                                               \
+    }                                                                                              \
+    else                                                                                           \
+      format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt, ##__VA_ARGS__);           \
+    exit(1);                                                                                       \
+  }
+#define COMPILE_NOTE(fmt, ...)                                                         \
   {                                                                                    \
-    if (MACROCALLS->length)                                                            \
-    {                                                                                  \
-      format_error(GETFNAME(((node_t *)MACROCALLS->data[MACROCALLS->length - 1])->fi), \
-                   GETSRC(((node_t *)MACROCALLS->data[MACROCALLS->length - 1])->fi),   \
-                   ((node_t *)MACROCALLS->data[MACROCALLS->length - 1])->pos, fmt,     \
-                   ##__VA_ARGS__);                                                     \
-      format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos,                    \
-                   "after the expansion of macro:");                                   \
-    }                                                                                  \
-    else                                                                               \
-      format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt,               \
-                   ##__VA_ARGS__);                                                     \
-    exit(1);                                                                           \
-  }
-#define COMPILE_NOTE(fmt, ...)                                         \
-  {                                                                    \
-    format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt, \
-                 ##__VA_ARGS__);                                       \
+    format_error(GETFNAME(node->fi), GETSRC(node->fi), node->pos, fmt, ##__VA_ARGS__); \
   }
 
 list_t *MACROCALLS;
@@ -5131,7 +5127,8 @@ node_t *mexpr_negate(node_t *a)
 
 node_t *mexpr_add(node_t *a, node_t *b)
 {
-  if (IS_STRING(a) && IS_STRING(b)) {
+  if (IS_STRING(a) && IS_STRING(b))
+  {
     char *buf = malloc(strlen(a->t->text) + strlen(b->t->text) + 1);
     strcpy(buf, a->t->text);
     strcat(buf, b->t->text);
@@ -5266,7 +5263,8 @@ size_t macro_rlimit = 100;
 
 node_t *mexpr_eval(node_t *node)
 {
-  if (mdepth >= macro_rlimit) {
+  if (mdepth >= macro_rlimit)
+  {
     COMPILE_ERROR("max. recursion depth (%d) reached while evaluating constant expression", macro_rlimit);
   }
 
@@ -5293,149 +5291,171 @@ node_t *mexpr_eval(node_t *node)
       node_t *a = mexpr_eval(node->a);
 
       node = mexpr_negate(a);
-    } break;
+    }
+    break;
 
     case N_EQUALS:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      node = mexpr_equals(a, b)? nodet(N_LITERAL, token(T_TRUE, "true")): nodet(N_LITERAL, token(T_FALSE, "false"));
-    } break;
+      node = mexpr_equals(a, b) ? nodet(N_LITERAL, token(T_TRUE, "true")) : nodet(N_LITERAL, token(T_FALSE, "false"));
+    }
+    break;
 
     case N_NOTEQUALS:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      node = !mexpr_equals(a, b)? nodet(N_LITERAL, token(T_TRUE, "true")): nodet(N_LITERAL, token(T_FALSE, "false"));
-    } break;
+      node = !mexpr_equals(a, b) ? nodet(N_LITERAL, token(T_TRUE, "true")) : nodet(N_LITERAL, token(T_FALSE, "false"));
+    }
+    break;
 
     case N_ADD:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      if (IS_STRING(a) && IS_STRING(b)) {
+      if (IS_STRING(a) && IS_STRING(b))
+      {
         node = mexpr_add(a, b);
 
         break;
       }
 
-      if (!IS_NUMBER(a) && IS_NUMBER(b)) {
+      if (!IS_NUMBER(a) && IS_NUMBER(b))
+      {
         node = node2(N_ADD, node->a, b);
 
         break;
       }
 
-      if (IS_NUMBER(a) && !IS_NUMBER(b)) {
+      if (IS_NUMBER(a) && !IS_NUMBER(b))
+      {
         node = node2(N_ADD, a, node->b);
 
         break;
       }
 
       node = mexpr_add(a, b);
-    } break;
+    }
+    break;
 
     case N_SUB:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      if (!IS_NUMBER(a) && IS_NUMBER(b)) {
+      if (!IS_NUMBER(a) && IS_NUMBER(b))
+      {
         node = node2(N_SUB, node->a, b);
 
         break;
       }
 
-      if (IS_NUMBER(a) && !IS_NUMBER(b)) {
+      if (IS_NUMBER(a) && !IS_NUMBER(b))
+      {
         node = node2(N_SUB, a, node->b);
 
         break;
       }
 
       node = mexpr_sub(a, b);
-    } break;
+    }
+    break;
 
     case N_MUL:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      if (!IS_NUMBER(a) && IS_NUMBER(b)) {
+      if (!IS_NUMBER(a) && IS_NUMBER(b))
+      {
         node = node2(N_MUL, node->a, b);
 
         break;
       }
 
-      if (IS_NUMBER(a) && !IS_NUMBER(b)) {
+      if (IS_NUMBER(a) && !IS_NUMBER(b))
+      {
         node = node2(N_MUL, a, node->b);
 
         break;
       }
 
       node = mexpr_mul(a, b);
-    } break;
+    }
+    break;
 
     case N_POW:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      if (!IS_NUMBER(a) && IS_NUMBER(b)) {
+      if (!IS_NUMBER(a) && IS_NUMBER(b))
+      {
         node = node2(N_POW, node->a, b);
 
         break;
       }
 
-      if (IS_NUMBER(a) && !IS_NUMBER(b)) {
+      if (IS_NUMBER(a) && !IS_NUMBER(b))
+      {
         node = node2(N_POW, a, node->b);
 
         break;
       }
 
       node = mexpr_pow(a, b);
-    } break;
+    }
+    break;
 
     case N_DIV:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      if (!IS_NUMBER(a) && IS_NUMBER(b)) {
+      if (!IS_NUMBER(a) && IS_NUMBER(b))
+      {
         node = node2(N_DIV, node->a, b);
 
         break;
       }
 
-      if (IS_NUMBER(a) && !IS_NUMBER(b)) {
+      if (IS_NUMBER(a) && !IS_NUMBER(b))
+      {
         node = node2(N_DIV, a, node->b);
 
         break;
       }
 
       node = mexpr_div(a, b);
-    } break;
+    }
+    break;
 
     case N_MOD:
     {
       node_t *a = mexpr_eval(node->a);
       node_t *b = mexpr_eval(node->b);
 
-      if (!IS_NUMBER(a) && IS_NUMBER(b)) {
+      if (!IS_NUMBER(a) && IS_NUMBER(b))
+      {
         node = node2(N_MOD, node->a, b);
 
         break;
       }
 
-      if (IS_NUMBER(a) && !IS_NUMBER(b)) {
+      if (IS_NUMBER(a) && !IS_NUMBER(b))
+      {
         node = node2(N_MOD, a, node->b);
 
         break;
       }
 
       node = mexpr_mod(a, b);
-    } break;
+    }
+    break;
 
     case N_IFEXPR:
     {
@@ -5445,7 +5465,8 @@ node_t *mexpr_eval(node_t *node)
         node = mexpr_eval(node->b);
       else
         node = mexpr_eval(node->c);
-    } break;
+    }
+    break;
 
     case N_TUPLE:
     case N_LIST:
@@ -5457,17 +5478,21 @@ node_t *mexpr_eval(node_t *node)
       {
         node_t *a = mexpr_eval(node->l->data[i]);
 
-        if (!IS_EXPR(a)) {
-          f = 1; break;
+        if (!IS_EXPR(a))
+        {
+          f = 1;
+          break;
         }
 
         list_push(l, a);
       }
 
-      if (f) break;
+      if (f)
+        break;
 
       node = nodel(node->tag, l);
-    } break;
+    }
+    break;
 
     case N_COMMA:
       node = mexpr_eval(list_index(node->l, -1));
@@ -5481,7 +5506,8 @@ node_t *mexpr_eval(node_t *node)
         list_push(args, mexpr_eval(node->l->data[i]));
 
       macro_t *m = find_macro(node->t->text, args->length, NULL);
-      if (m) {
+      if (m)
+      {
         list_push(MVARS, table_new());
 
         node_t *r = run_macro(m, args);
@@ -5490,7 +5516,8 @@ node_t *mexpr_eval(node_t *node)
 
         node = mexpr_eval(expand_mvars(node, r, 1));
       }
-    } break;
+    }
+    break;
 
     default:
       break;