c2xml.c

   1 /*
   2  * Sparse c2xml
   3  *
   4  * Dumps the parse tree as an xml document
   5  *
   6  * Copyright (C) 2007 Rob Taylor
   7  *
   8  * Licensed under the Open Software License version 1.1
   9  */
  10 #include <stdlib.h>
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <unistd.h>
  14 #include <fcntl.h>
  15 #include <assert.h>
  16 #include <libxml/parser.h>
  17 #include <libxml/tree.h>
  18
  19 #include "expression.h"
  20 #include "parse.h"
  21 #include "scope.h"
  22 #include "symbol.h"
  23
  24 static xmlDocPtr doc = NULL;       /* document pointer */
  25 static xmlNodePtr root_node = NULL;/* root node pointer */
  26 static int idcount = 0;
  27
  28 static void examine_symbol(struct symbol *sym, xmlNodePtr node);
  29
  30 static xmlAttrPtr newProp(xmlNodePtr node, const char *name, const char *value)
  31 {
  32         return xmlNewProp(node, BAD_CAST name, BAD_CAST value);
  33 }
  34
  35 static xmlAttrPtr newNumProp(xmlNodePtr node, const char *name, int value)
  36 {
  37         char buf[256];
  38         snprintf(buf, 256, "%d", value);
  39         return newProp(node, name, buf);
  40 }
  41
  42 static xmlAttrPtr newIdProp(xmlNodePtr node, const char *name, unsigned int id)
  43 {
  44         char buf[256];
  45         snprintf(buf, 256, "_%d", id);
  46         return newProp(node, name, buf);
  47 }
  48
  49 static xmlNodePtr new_sym_node(struct symbol *sym, const char *name, xmlNodePtr parent)
  50 {
  51         xmlNodePtr node;
  52         const char *ident = show_ident(sym->ident);
  53
  54         assert(name != NULL);
  55         assert(sym != NULL);
  56         assert(parent != NULL);
  57
  58         node = xmlNewChild(parent, NULL, BAD_CAST "symbol", NULL);
  59
  60         newProp(node, "type", name);
  61
  62         newIdProp(node, "id", idcount);
  63
  64         if (sym->ident && ident)
  65                 newProp(node, "ident", ident);
  66         newProp(node, "file", stream_name(sym->pos.stream));
  67
  68         newNumProp(node, "start-line", sym->pos.line);
  69         newNumProp(node, "start-col", sym->pos.pos);
  70
  71         if (sym->endpos.type) {
  72                 newNumProp(node, "end-line", sym->endpos.line);
  73                 newNumProp(node, "end-col", sym->endpos.pos);
  74                 if (sym->pos.stream != sym->endpos.stream)
  75                         newProp(node, "end-file", stream_name(sym->endpos.stream));
  76         }
  77         sym->aux = node;
  78
  79         idcount++;
  80
  81         return node;
  82 }
  83
  84 static inline void examine_members(struct symbol_list *list, xmlNodePtr node)
  85 {
  86         struct symbol *sym;
  87
  88         FOR_EACH_PTR(list, sym) {
  89                 examine_symbol(sym, node);
  90         } END_FOR_EACH_PTR(sym);
  91 }
  92
  93 static void examine_modifiers(struct symbol *sym, xmlNodePtr node)
  94 {
  95         const char *modifiers[] = {
  96                         "auto",
  97                         "register",
  98                         "static",
  99                         "extern",
 100                         "const",
 101                         "volatile",
 102                         "signed",
 103                         "unsigned",
 104                         "char",
 105                         "short",
 106                         "long",
 107                         "long-long",
 108                         "typedef",
 109                         NULL,
 110                         NULL,
 111                         NULL,
 112                         NULL,
 113                         NULL,
 114                         "inline",
 115                         "addressable",
 116                         "nocast",
 117                         "noderef",
 118                         "accessed",
 119                         "toplevel",
 120                         "label",
 121                         "assigned",
 122                         "type-type",
 123                         "safe",
 124                         "user-type",
 125                         "force",
 126                         "explicitly-signed",
 127                         "bitwise"};
 128
 129         int i;
 130
 131         if (sym->namespace != NS_SYMBOL)
 132                 return;
 133
 134         /*iterate over the 32 bit bitfield*/
 135         for (i=0; i < 32; i++) {
 136                 if ((sym->ctype.modifiers & 1<<i) && modifiers[i])
 137                         newProp(node, modifiers[i], "1");
 138         }
 139 }
 140
 141 static void
 142 examine_layout(struct symbol *sym, xmlNodePtr node)
 143 {
 144         examine_symbol_type(sym);
 145
 146         newNumProp(node, "bit-size", sym->bit_size);
 147         newNumProp(node, "alignment", sym->ctype.alignment);
 148         newNumProp(node, "offset", sym->offset);
 149         if (is_bitfield_type(sym)) {
 150                 newNumProp(node, "bit-offset", sym->bit_offset);
 151         }
 152 }
 153
 154 static void examine_symbol(struct symbol *sym, xmlNodePtr node)
 155 {
 156         xmlNodePtr child = NULL;
 157         const char *base;
 158         int array_size;
 159
 160         if (!sym)
 161                 return;
 162         if (sym->aux)           /*already visited */
 163                 return;
 164
 165         if (sym->ident && sym->ident->reserved)
 166                 return;
 167
 168         child = new_sym_node(sym, get_type_name(sym->type), node);
 169         examine_modifiers(sym, child);
 170         examine_layout(sym, child);
 171
 172         if (sym->ctype.base_type) {
 173                 if ((base = builtin_typename(sym->ctype.base_type)) == NULL) {
 174                         if (!sym->ctype.base_type->aux) {
 175                                 examine_symbol(sym->ctype.base_type, root_node);
 176                         }
 177                         xmlNewProp(child, BAD_CAST "base-type",
 178                                    xmlGetProp((xmlNodePtr)sym->ctype.base_type->aux, BAD_CAST "id"));
 179                 } else {
 180                         newProp(child, "base-type-builtin", base);
 181                 }
 182         }
 183         if (sym->array_size) {
 184                 /* TODO: modify get_expression_value to give error return */
 185                 array_size = get_expression_value(sym->array_size);
 186                 newNumProp(child, "array-size", array_size);
 187         }
 188
 189
 190         switch (sym->type) {
 191         case SYM_STRUCT:
 192         case SYM_UNION:
 193                 examine_members(sym->symbol_list, child);
 194                 break;
 195         case SYM_FN:
 196                 examine_members(sym->arguments, child);
 197                 break;
 198         case SYM_UNINITIALIZED:
 199                 newProp(child, "base-type-builtin", builtin_typename(sym));
 200                 break;
 201         }
 202         return;
 203 }
 204
 205 static struct position *get_expansion_end (struct token *token)
 206 {
 207         struct token *p1, *p2;
 208
 209         for (p1=NULL, p2=NULL;
 210              !eof_token(token);
 211              p2 = p1, p1 = token, token = token->next);
 212
 213         if (p2)
 214                 return &(p2->pos);
 215         else
 216                 return NULL;
 217 }
 218
 219 static void examine_macro(struct symbol *sym, xmlNodePtr node)
 220 {
 221         xmlNodePtr child;
 222         struct position *pos;
 223
 224         /* this should probably go in the main codebase*/
 225         pos = get_expansion_end(sym->expansion);
 226         if (pos)
 227                 sym->endpos = *pos;
 228         else
 229                 sym->endpos = sym->pos;
 230
 231         child = new_sym_node(sym, "macro", node);
 232 }
 233
 234 static void examine_namespace(struct symbol *sym)
 235 {
 236         if (sym->ident && sym->ident->reserved)
 237                 return;
 238
 239         switch(sym->namespace) {
 240         case NS_MACRO:
 241                 examine_macro(sym, root_node);
 242                 break;
 243         case NS_TYPEDEF:
 244         case NS_STRUCT:
 245         case NS_SYMBOL:
 246                 examine_symbol(sym, root_node);
 247                 break;
 248         case NS_NONE:
 249         case NS_LABEL:
 250         case NS_ITERATOR:
 251         case NS_UNDEF:
 252         case NS_PREPROCESSOR:
 253         case NS_KEYWORD:
 254                 break;
 255         default:
 256                 die("Unrecognised namespace type %d",sym->namespace);
 257         }
 258
 259 }
 260
 261 static int get_stream_id (const char *name)
 262 {
 263         int i;
 264         for (i=0; i<input_stream_nr; i++) {
 265                 if (strcmp(name, stream_name(i))==0)
 266                         return i;
 267         }
 268         return -1;
 269 }
 270
 271 static inline void examine_symbol_list(const char *file, struct symbol_list *list)
 272 {
 273         struct symbol *sym;
 274         int stream_id = get_stream_id (file);
 275
 276         if (!list)
 277                 return;
 278         FOR_EACH_PTR(list, sym) {
 279                 if (sym->pos.stream == stream_id)
 280                         examine_namespace(sym);
 281         } END_FOR_EACH_PTR(sym);
 282 }
 283
 284 int main(int argc, char **argv)
 285 {
 286         struct string_list *filelist = NULL;
 287         struct symbol_list *symlist = NULL;
 288         char *file;
 289
 290         doc = xmlNewDoc(BAD_CAST "1.0");
 291         root_node = xmlNewNode(NULL, BAD_CAST "parse");
 292         xmlDocSetRootElement(doc, root_node);
 293
 294 /* - A DTD is probably unnecessary for something like this
 295
 296         dtd = xmlCreateIntSubset(doc, "parse", "http://www.kernel.org/pub/software/devel/sparse/parse.dtd" NULL, "parse.dtd");
 297
 298         ns = xmlNewNs (root_node, "http://www.kernel.org/pub/software/devel/sparse/parse.dtd", NULL);
 299
 300         xmlSetNs(root_node, ns);
 301 */
 302         symlist = sparse_initialize(argc, argv, &filelist);
 303
 304         FOR_EACH_PTR_NOTAG(filelist, file) {
 305                 examine_symbol_list(file, symlist);
 306                 sparse_keep_tokens(file);
 307                 examine_symbol_list(file, file_scope->symbols);
 308                 examine_symbol_list(file, global_scope->symbols);
 309         } END_FOR_EACH_PTR_NOTAG(file);
 310
 311
 312         xmlSaveFormatFileEnc("-", doc, "UTF-8", 1);
 313         xmlFreeDoc(doc);
 314         xmlCleanupParser();
 315
 316         return 0;
 317 }
 318