ast-inspect.c

   1
   2 #include "token.h"
   3 #include "parse.h"
   4 #include "symbol.h"
   5 #include "ast-inspect.h"
   6 #include "expression.h"
   7
   8 static inline void inspect_ptr_list(AstNode *node, const char *name, void (*inspect)(AstNode *))
   9 {
  10         struct ptr_list *ptrlist = node->ptr;
  11         void *ptr;
  12         int i = 0;
  13
  14         node->text = g_strdup_printf("%s %s:", node->text, name);
  15         FOR_EACH_PTR(ptrlist, ptr) {
  16                 char *index = g_strdup_printf("%d: ", i++);
  17                 ast_append_child(node, index, ptr, inspect);
  18         } END_FOR_EACH_PTR(ptr);
  19 }
  20
  21
  22 static const char *statement_type_name(enum statement_type type)
  23 {
  24         static const char *statement_type_name[] = {
  25                 [STMT_NONE] = "STMT_NONE",
  26                 [STMT_DECLARATION] = "STMT_DECLARATION",
  27                 [STMT_EXPRESSION] = "STMT_EXPRESSION",
  28                 [STMT_COMPOUND] = "STMT_COMPOUND",
  29                 [STMT_IF] = "STMT_IF",
  30                 [STMT_RETURN] = "STMT_RETURN",
  31                 [STMT_CASE] = "STMT_CASE",
  32                 [STMT_SWITCH] = "STMT_SWITCH",
  33                 [STMT_ITERATOR] = "STMT_ITERATOR",
  34                 [STMT_LABEL] = "STMT_LABEL",
  35                 [STMT_GOTO] = "STMT_GOTO",
  36                 [STMT_ASM] = "STMT_ASM",
  37                 [STMT_CONTEXT] = "STMT_CONTEXT",
  38                 [STMT_RANGE] = "STMT_RANGE",
  39         };
  40         return statement_type_name[type] ?: "UNKNOWN_STATEMENT_TYPE";
  41 }
  42
  43 void inspect_statement(AstNode *node)
  44 {
  45         struct statement *stmt = node->ptr;
  46         node->text = g_strdup_printf("%s %s:", node->text, statement_type_name(stmt->type));
  47         switch (stmt->type) {
  48                 case STMT_COMPOUND:
  49                         ast_append_child(node, "stmts:", stmt->stmts, inspect_statement_list);
  50                         break;
  51                 case STMT_EXPRESSION:
  52                         ast_append_child(node, "expression:", stmt->expression, inspect_expression);
  53                         break;
  54                 case STMT_IF:
  55                         ast_append_child(node, "conditional:", stmt->if_conditional, inspect_expression);
  56                         ast_append_child(node, "if_true:", stmt->if_true, inspect_statement);
  57                         ast_append_child(node, "if_false:", stmt->if_false, inspect_statement);
  58                         break;
  59                 case STMT_ITERATOR:
  60                         ast_append_child(node, "break:", stmt->iterator_break, inspect_symbol);
  61                         ast_append_child(node, "continue:", stmt->iterator_continue, inspect_symbol);
  62                         ast_append_child(node, "pre_statement:", stmt->iterator_pre_statement,
  63                                          inspect_statement);
  64                         ast_append_child(node, "statement:", stmt->iterator_statement,
  65                                          inspect_statement);
  66                         ast_append_child(node, "post_statement:", stmt->iterator_post_statement,
  67                                          inspect_statement);
  68                         break;
  69
  70                 case STMT_SWITCH:
  71                         ast_append_child(node, "switch_expression:", stmt->switch_expression, inspect_expression);
  72                         ast_append_child(node, "switch_statement:", stmt->switch_statement, inspect_statement);
  73                         ast_append_child(node, "switch_break:", stmt->switch_break, inspect_symbol);
  74                         ast_append_child(node, "switch_case:", stmt->switch_case, inspect_symbol);
  75                         break;
  76                 case STMT_CASE:
  77                         ast_append_child(node, "case_expression:", stmt->case_expression, inspect_expression);
  78                         ast_append_child(node, "case_to:", stmt->case_to, inspect_expression);
  79                         ast_append_child(node, "case_statement:", stmt->case_statement, inspect_statement);
  80                         ast_append_child(node, "case_label:", stmt->case_label, inspect_symbol);
  81                         break;
  82                 case STMT_RETURN:
  83                         ast_append_child(node, "ret_value:", stmt->ret_value, inspect_expression);
  84                         ast_append_child(node, "ret_target:", stmt->ret_target, inspect_symbol);
  85                         break;
  86
  87                 default:
  88                         break;
  89         }
  90 }
  91
  92
  93 void inspect_statement_list(AstNode *node)
  94 {
  95         inspect_ptr_list(node, "statement_list", inspect_statement);
  96 }
  97
  98
  99 static const char *symbol_type_name(enum type type)
 100 {
 101         static const char *type_name[] = {
 102                 [SYM_UNINITIALIZED] = "SYM_UNINITIALIZED",
 103                 [SYM_PREPROCESSOR] = "SYM_PREPROCESSOR",
 104                 [SYM_BASETYPE] = "SYM_BASETYPE",
 105                 [SYM_NODE] = "SYM_NODE",
 106                 [SYM_PTR] = "SYM_PTR",
 107                 [SYM_FN] = "SYM_FN",
 108                 [SYM_ARRAY] = "SYM_ARRAY",
 109                 [SYM_STRUCT] = "SYM_STRUCT",
 110                 [SYM_UNION] = "SYM_UNION",
 111                 [SYM_ENUM] = "SYM_ENUM",
 112                 [SYM_TYPEDEF] = "SYM_TYPEDEF",
 113                 [SYM_TYPEOF] = "SYM_TYPEOF",
 114                 [SYM_MEMBER] = "SYM_MEMBER",
 115                 [SYM_BITFIELD] = "SYM_BITFIELD",
 116                 [SYM_LABEL] = "SYM_LABEL",
 117                 [SYM_RESTRICT] = "SYM_RESTRICT",
 118                 [SYM_FOULED] = "SYM_FOULED",
 119                 [SYM_KEYWORD] = "SYM_KEYWORD",
 120                 [SYM_BAD] = "SYM_BAD",
 121         };
 122         return type_name[type] ?: "UNKNOWN_TYPE";
 123 }
 124
 125
 126 void inspect_symbol(AstNode *node)
 127 {
 128         struct symbol *sym = node->ptr;
 129         node->text = g_strdup_printf("%s %s: %s", node->text, symbol_type_name(sym->type),
 130                                       builtin_typename(sym) ?: show_ident(sym->ident));
 131         ast_append_child(node, "ctype.base_type:", sym->ctype.base_type,inspect_symbol);
 132
 133         switch (sym->namespace) {
 134                 case NS_PREPROCESSOR:
 135                         break;
 136                 default:
 137                         ast_append_child(node, "arguments:", sym->arguments, inspect_symbol_list);
 138                         ast_append_child(node, "symbol_list:", sym->symbol_list, inspect_symbol_list);
 139                         ast_append_child(node, "stmt:", sym->stmt, inspect_statement);
 140                         break;
 141         }
 142 }
 143
 144
 145 void inspect_symbol_list(AstNode *node)
 146 {
 147         inspect_ptr_list(node, "symbol_list", inspect_symbol);
 148 }
 149
 150
 151 static const char *expression_type_name(enum expression_type type)
 152 {
 153         static const char *expression_type_name[] = {
 154                 [EXPR_VALUE] = "EXPR_VALUE",
 155                 [EXPR_STRING] = "EXPR_STRING",
 156                 [EXPR_SYMBOL] = "EXPR_SYMBOL",
 157                 [EXPR_TYPE] = "EXPR_TYPE",
 158                 [EXPR_BINOP] = "EXPR_BINOP",
 159                 [EXPR_ASSIGNMENT] = "EXPR_ASSIGNMENT",
 160                 [EXPR_LOGICAL] = "EXPR_LOGICAL",
 161                 [EXPR_DEREF] = "EXPR_DEREF",
 162                 [EXPR_PREOP] = "EXPR_PREOP",
 163                 [EXPR_POSTOP] = "EXPR_POSTOP",
 164                 [EXPR_CAST] = "EXPR_CAST",
 165                 [EXPR_FORCE_CAST] = "EXPR_FORCE_CAST",
 166                 [EXPR_IMPLIED_CAST] = "EXPR_IMPLIED_CAST",
 167                 [EXPR_SIZEOF] = "EXPR_SIZEOF",
 168                 [EXPR_ALIGNOF] = "EXPR_ALIGNOF",
 169                 [EXPR_PTRSIZEOF] = "EXPR_PTRSIZEOF",
 170                 [EXPR_CONDITIONAL] = "EXPR_CONDITIONAL",
 171                 [EXPR_SELECT] = "EXPR_SELECT",
 172                 [EXPR_STATEMENT] = "EXPR_STATEMENT",
 173                 [EXPR_CALL] = "EXPR_CALL",
 174                 [EXPR_COMMA] = "EXPR_COMMA",
 175                 [EXPR_COMPARE] = "EXPR_COMPARE",
 176                 [EXPR_LABEL] = "EXPR_LABEL",
 177                 [EXPR_INITIALIZER] = "EXPR_INITIALIZER",
 178                 [EXPR_IDENTIFIER] = "EXPR_IDENTIFIER",
 179                 [EXPR_INDEX] = "EXPR_INDEX",
 180                 [EXPR_POS] = "EXPR_POS",
 181                 [EXPR_FVALUE] = "EXPR_FVALUE",
 182                 [EXPR_SLICE] = "EXPR_SLICE",
 183                 [EXPR_OFFSETOF] = "EXPR_OFFSETOF",
 184         };
 185         return expression_type_name[type] ?: "UNKNOWN_EXPRESSION_TYPE";
 186 }
 187
 188 void inspect_expression(AstNode *node)
 189 {
 190         struct expression *expr = node->ptr;
 191         node->text = g_strdup_printf("%s %s", node->text, expression_type_name(expr->type));
 192         switch (expr->type) {
 193                 case EXPR_STATEMENT:
 194                         ast_append_child(node, "statement:", expr->statement, inspect_statement);
 195                         break;
 196                 case EXPR_BINOP:
 197                 case EXPR_COMMA:
 198                 case EXPR_COMPARE:
 199                 case EXPR_LOGICAL:
 200                 case EXPR_ASSIGNMENT:
 201                         ast_append_child(node, "left:", expr->left, inspect_expression);
 202                         ast_append_child(node, "right:", expr->right, inspect_expression);
 203                         break;
 204
 205                 case EXPR_CAST:
 206                 case EXPR_FORCE_CAST:
 207                 case EXPR_IMPLIED_CAST:
 208                         ast_append_child(node, "cast_type:", expr->cast_type, inspect_symbol);
 209                         ast_append_child(node, "cast_expression:", expr->cast_expression, inspect_expression);
 210                         break;
 211
 212                 case EXPR_PREOP:
 213                         ast_append_child(node, "unop:", expr->unop, inspect_expression);
 214                         break;
 215
 216                 default:
 217                         break;
 218         }
 219 }
 220
 221
 222