smatch_var_sym.c

   1 /*
   2  * sparse/smatch_var_sym.c
   3  *
   4  * Copyright (C) 2013 Oracle.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "smatch.h"
  11
  12 ALLOCATOR(var_sym, "var_sym structs");
  13
  14 struct var_sym *alloc_var_sym(const char *var, struct symbol *sym)
  15 {
  16         struct var_sym *tmp;
  17
  18         tmp = __alloc_var_sym(0);
  19         tmp->var = alloc_string(var);
  20         tmp->sym = sym;
  21         return tmp;
  22 }
  23
  24 struct var_sym_list *expr_to_vsl(struct expression *expr)
  25 {
  26         struct var_sym_list *ret = NULL;
  27         char *var;
  28         struct symbol *sym;
  29
  30         expr = strip_expr(expr);
  31         if (!expr)
  32                 return NULL;
  33
  34         if (expr->type == EXPR_BINOP ||
  35             expr->type == EXPR_LOGICAL ||
  36             expr->type == EXPR_COMPARE) {
  37                 struct var_sym_list *left, *right;
  38
  39                 left = expr_to_vsl(expr->left);
  40                 right = expr_to_vsl(expr->right);
  41                 ret = combine_var_sym_lists(left, right);
  42                 free_var_syms_and_list(&left);
  43                 free_var_syms_and_list(&right);
  44                 return ret;
  45         }
  46         var = expr_to_var_sym(expr, &sym);
  47         if (!var || !sym) {
  48                 free_string(var);
  49                 return NULL;
  50         }
  51         add_var_sym(&ret, var, sym);
  52         return ret;
  53 }
  54
  55 void add_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym)
  56 {
  57         struct var_sym *tmp;
  58
  59         if (in_var_sym_list(*list, var, sym))
  60                 return;
  61         tmp = alloc_var_sym(var, sym);
  62         add_ptr_list(list, tmp);
  63 }
  64
  65 void add_var_sym_expr(struct var_sym_list **list, struct expression *expr)
  66 {
  67         char *var;
  68         struct symbol *sym;
  69
  70         var = expr_to_var_sym(expr, &sym);
  71         if (!var || !sym)
  72                 goto free;
  73         add_var_sym(list, var, sym);
  74 free:
  75         free_string(var);
  76 }
  77
  78 static void free_var_sym(struct var_sym *vs)
  79 {
  80         free_string(vs->var);
  81         __free_var_sym(vs);
  82 }
  83
  84 void del_var_sym(struct var_sym_list **list, const char *var, struct symbol *sym)
  85 {
  86         struct var_sym *tmp;
  87
  88         FOR_EACH_PTR(*list, tmp) {
  89                 if (tmp->sym == sym && strcmp(tmp->var, var) == 0) {
  90                         DELETE_CURRENT_PTR(tmp);
  91                         free_var_sym(tmp);
  92                         return;
  93                 }
  94         } END_FOR_EACH_PTR(tmp);
  95 }
  96
  97 int in_var_sym_list(struct var_sym_list *list, const char *var, struct symbol *sym)
  98 {
  99         struct var_sym *tmp;
 100
 101         FOR_EACH_PTR(list, tmp) {
 102                 if (tmp->sym == sym && strcmp(tmp->var, var) == 0)
 103                         return 1;
 104         } END_FOR_EACH_PTR(tmp);
 105         return 0;
 106 }
 107
 108 struct var_sym_list *clone_var_sym_list(struct var_sym_list *from_vsl)
 109 {
 110         struct var_sym *tmp, *clone_vs;
 111         struct var_sym_list *to_vsl = NULL;
 112
 113         FOR_EACH_PTR(from_vsl, tmp) {
 114                 clone_vs = alloc_var_sym(tmp->var, tmp->sym);
 115                 add_ptr_list(&to_vsl, clone_vs);
 116         } END_FOR_EACH_PTR(tmp);
 117         return to_vsl;
 118 }
 119
 120 void merge_var_sym_list(struct var_sym_list **dest, struct var_sym_list *src)
 121 {
 122         struct var_sym *tmp;
 123
 124         FOR_EACH_PTR(src, tmp) {
 125                 add_var_sym(dest, tmp->var, tmp->sym);
 126         } END_FOR_EACH_PTR(tmp);
 127 }
 128
 129 struct var_sym_list *combine_var_sym_lists(struct var_sym_list *one, struct var_sym_list *two)
 130 {
 131         struct var_sym_list *to_vsl;
 132
 133         to_vsl = clone_var_sym_list(one);
 134         merge_var_sym_list(&to_vsl, two);
 135         return to_vsl;
 136 }
 137
 138 void free_var_sym_list(struct var_sym_list **list)
 139 {
 140         __free_ptr_list((struct ptr_list **)list);
 141 }
 142
 143 void free_var_syms_and_list(struct var_sym_list **list)
 144 {
 145         struct var_sym *tmp;
 146
 147         FOR_EACH_PTR(*list, tmp) {
 148                 free_var_sym(tmp);
 149         } END_FOR_EACH_PTR(tmp);
 150         free_var_sym_list(list);
 151 }
 152