show-parse.c

   1 /*
   2  * sparse/show-parse.c
   3  *
   4  * Copyright (C) 2003 Linus Torvalds, all rights reserved.
   5  *
   6  * Print out results of parsing for debugging and testing.
   7  */
   8 #include <stdarg.h>
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <ctype.h>
  13 #include <unistd.h>
  14 #include <fcntl.h>
  15
  16 #include "lib.h"
  17 #include "token.h"
  18 #include "parse.h"
  19 #include "symbol.h"
  20 #include "scope.h"
  21 #include "expression.h"
  22
  23 /*
  24  * Symbol type printout. The type system is by far the most
  25  * complicated part of C - everything else is trivial.
  26  */
  27 const char *modifier_string(unsigned long mod)
  28 {
  29         static char buffer[100];
  30         char *p = buffer;
  31         const char *res,**ptr, *names[] = {
  32                 "auto", "register", "static", "extern",
  33                 "const", "volatile", "signed", "unsigned",
  34                 "char", "short", "long", "long",
  35                 "typdef", "structof", "unionof", "enum",
  36                 "typeof", "attribute",
  37                 NULL
  38         };
  39         ptr = names;
  40         while ((res = *ptr++) != NULL) {
  41                 if (mod & 1) {
  42                         char c;
  43                         *p++ = ' ';
  44                         while ((c = *res++) != '\0')
  45                                 *p++ = c;
  46                 }
  47                 mod >>= 1;
  48         }
  49         *p++ = 0;
  50         *p++ = 0;
  51         return buffer+1;
  52 }
  53
  54 void show_struct_member(struct symbol *sym, void *data, int flags)
  55 {
  56         if (flags & ITERATE_FIRST)
  57                 printf(" { ");
  58         printf("%s", show_token(sym->token));
  59         if (flags & ITERATE_LAST)
  60                 printf(" } ");
  61         else
  62                 printf(", ");
  63 }
  64
  65 void show_type_details(unsigned int modifiers, struct symbol *sym)
  66 {
  67         if (!sym) {
  68                 printf(" <notype>");
  69                 return;
  70         }
  71
  72         if (sym == &int_type) {
  73                 if (modifiers & (MOD_CHAR | MOD_SHORT | MOD_LONG))
  74                         return;
  75                 printf(" int");
  76                 return;
  77         }
  78         if (sym == &fp_type) {
  79                 printf(" float");
  80                 return;
  81         }
  82         if (sym == &void_type) {
  83                 printf(" void");
  84                 return;
  85         }
  86         if (sym == &vector_type) {
  87                 printf(" vector");
  88                 return;
  89         }
  90         if (sym == &bad_type) {
  91                 printf(" <badtype>");
  92                 return;
  93         }
  94         if (sym->type == SYM_STRUCT) {
  95                 printf(" struct %s", show_token(sym->token));
  96                 symbol_iterate(sym->symbol_list, show_struct_member, NULL);
  97                 return;
  98         }
  99         if (sym->type == SYM_UNION) {
 100                 printf(" union %s", show_token(sym->token));
 101                 symbol_iterate(sym->symbol_list, show_struct_member, NULL);
 102                 return;
 103         }
 104         if (sym->type == SYM_ENUM) {
 105                 printf(" enum %s", show_token(sym->token));
 106                 return;
 107         }
 108
 109         if (sym->type == SYM_PTR)
 110                 printf(" *");
 111         else if (sym->type == SYM_FN)
 112                 printf(" <fn>");
 113         else
 114                 printf(" strange type %d", sym->type);
 115
 116         if (sym->token)
 117                 printf(" '%s'", show_token(sym->token));
 118
 119         printf("%s", modifier_string(sym->ctype.modifiers));
 120         show_type_details(sym->ctype.modifiers, sym->ctype.base_type);
 121 }
 122
 123 static void show_one_symbol(struct symbol *sym, void *sep, int flags)
 124 {
 125         show_symbol(sym);
 126         if (!(flags & ITERATE_LAST))
 127                 printf("%s", (const char *)sep);
 128 }
 129
 130 void show_symbol_list(struct symbol_list *list, const char *sep)
 131 {
 132         symbol_iterate(list, show_one_symbol, (void *)sep);
 133 }
 134
 135 void show_type_list(struct symbol *sym)
 136 {
 137         while (sym) {
 138                 show_symbol(sym);
 139                 sym = sym->next;
 140         }
 141 }
 142
 143 void show_type(struct symbol *sym)
 144 {
 145         struct ctype *ctype = &sym->ctype;
 146
 147         if (!sym) {
 148                 printf(" <typeless>");
 149                 return;
 150         }
 151
 152         printf("%s", modifier_string(sym->ctype.modifiers));
 153
 154         switch (sym->type) {
 155         case SYM_PTR:
 156                 show_type(sym->ctype.base_type);
 157                 printf(" *");
 158                 break;
 159
 160         case SYM_FN:
 161                 printf(" ");
 162                 show_type(sym->ctype.base_type);
 163                 printf(" <fn>(");
 164                 show_symbol_list(sym->arguments, ", ");
 165                 printf(")");
 166                 break;
 167
 168         case SYM_ARRAY:
 169                 printf("<array of>");
 170                 show_type(sym->ctype.base_type);
 171                 printf("[ ... ]");
 172                 break;
 173
 174         default:
 175                 show_type_details(ctype->modifiers, ctype->base_type);
 176                 break;
 177         }
 178 }
 179
 180 void show_symbol(struct symbol *sym)
 181 {
 182         if (!sym) {
 183                 printf("<anon symbol>");
 184                 return;
 185         }
 186         switch (sym->type) {
 187         case SYM_FN:
 188                 printf("%s: ", show_token(sym->token));
 189                 show_type(sym);
 190                 printf("\n");
 191                 show_statement(sym->stmt);
 192                 break;
 193         default:
 194                 show_type(sym);
 195                 printf(": %s", show_token(sym->token));
 196                 break;
 197         }
 198 }
 199
 200
 201 /*
 202  * Print out a statement
 203  */
 204 void show_statement(struct statement *stmt)
 205 {
 206         if (!stmt) {
 207                 printf("\t<nostatement>");
 208                 return;
 209         }
 210         switch (stmt->type) {
 211         case STMT_RETURN:
 212                 printf("\treturn ");
 213                 show_expression(stmt->expression);
 214                 break;
 215         case STMT_COMPOUND:
 216                 printf("{\n");
 217                 if (stmt->syms) {
 218                         printf("\t");
 219                         show_symbol_list(stmt->syms, "\n\t");
 220                         printf("\n\n");
 221                 }
 222                 show_statement_list(stmt->stmts, ";\n");
 223                 printf("\n}\n\n");
 224                 break;
 225         case STMT_EXPRESSION:
 226                 printf("\t");
 227                 show_expression(stmt->expression);
 228                 return;
 229         case STMT_IF:
 230                 printf("\tif (");
 231                 show_expression(stmt->if_conditional);
 232                 printf(")\n");
 233                 show_statement(stmt->if_true);
 234                 if (stmt->if_false) {
 235                         printf("\nelse\n");
 236                         show_statement(stmt->if_false);
 237                 }
 238                 break;
 239         case STMT_SWITCH:
 240                 printf("\tswitch (");
 241                 show_expression(stmt->switch_expression);
 242                 printf(")\n");
 243                 show_statement(stmt->switch_statement);
 244                 break;
 245
 246         case STMT_CASE:
 247                 if (!stmt->case_expression)
 248                         printf("default");
 249                 else {
 250                         printf("case ");
 251                         show_expression(stmt->case_expression);
 252                         if (stmt->case_to) {
 253                                 printf(" ... ");
 254                                 show_expression(stmt->case_to);
 255                         }
 256                 }
 257                 printf(":");
 258                 show_statement(stmt->case_statement);
 259                 break;
 260
 261         case STMT_BREAK:
 262                 printf("\tbreak");
 263                 break;
 264
 265         case STMT_WHILE:
 266                 printf("\twhile (");
 267                 show_expression(stmt->e1);
 268                 printf(")\n");
 269                 show_statement(stmt->iterate);
 270                 break;
 271
 272         case STMT_DO:
 273                 printf("\tdo");
 274                 show_statement(stmt->iterate);
 275                 printf("\nwhile (");
 276                 show_expression(stmt->e1);
 277                 printf(")\n");
 278                 break;
 279
 280         case STMT_FOR:
 281                 printf("\tfor (" );
 282                 show_expression(stmt->e1);
 283                 printf(" ; ");
 284                 show_expression(stmt->e2);
 285                 printf(" ; ");
 286                 show_expression(stmt->e3);
 287                 printf(")\n");
 288                 show_statement(stmt->iterate);
 289                 break;
 290
 291         default:
 292                 printf("WTF");
 293         }
 294 }
 295
 296 static void show_one_statement(struct statement *stmt, void *sep, int flags)
 297 {
 298         show_statement(stmt);
 299         if (!(flags & ITERATE_LAST))
 300                 printf("%s", (const char *)sep);
 301 }
 302
 303 void show_statement_list(struct statement_list *stmt, const char *sep)
 304 {
 305         statement_iterate(stmt, show_one_statement, (void *)sep);
 306 }
 307
 308 /*
 309  * Print out an expression
 310  */
 311 void show_expression(struct expression *expr)
 312 {
 313         if (!expr)
 314                 return;
 315
 316         printf("< ");
 317         switch (expr->type) {
 318         case EXPR_BINOP:
 319                 show_expression(expr->left);
 320                 printf(" %s ", show_special(expr->op));
 321                 show_expression(expr->right);
 322                 break;
 323         case EXPR_PREOP:
 324                 printf("%s<", show_special(expr->op));
 325                 show_expression(expr->unop);
 326                 printf(">");
 327                 break;
 328         case EXPR_POSTOP:
 329                 show_expression(expr->unop);
 330                 printf(" %s ", show_special(expr->op));
 331                 break;
 332         case EXPR_CONSTANT:
 333                 printf("%s", show_token(expr->token));
 334                 break;
 335         case EXPR_SYMBOL:
 336                 if (!expr->symbol) {
 337                         warn(expr->token, "undefined symbol '%s'", show_token(expr->token));
 338                         printf("<nosymbol>");
 339                         break;
 340                 }
 341                 printf("<%s:", show_token(expr->symbol->token));
 342                 show_type(expr->symbol);
 343                 printf(">");
 344                 break;
 345         case EXPR_DEREF:
 346                 show_expression(expr->deref);
 347                 printf("%s", show_special(expr->op));
 348                 printf("%s", show_token(expr->member));
 349                 break;
 350         case EXPR_CAST:
 351                 printf("<cast>(");
 352                 show_type(expr->cast_type);
 353                 printf(")");
 354                 show_expression(expr->cast_expression);
 355                 break;
 356         default:
 357                 printf("WTF");
 358         }
 359         printf(" >");
 360 }
 361
 362