smatch_extra_helper.c

   1 /*
   2  * sparse/smatch_extra_helper.c
   3  *
   4  * Copyright (C) 2009 Dan Carpenter.
   5  *
   6  * Licensed under the Open Software License version 1.1
   7  *
   8  */
   9
  10 #include "smatch.h"
  11 #include "smatch_extra.h"
  12
  13 ALLOCATOR(data_info, "smatch extra data");
  14 __DO_ALLOCATOR(long long, sizeof(long long), __alignof__(long long), "numbers", sm_num);
  15
  16 void print_num_list(struct num_list *list)
  17 {
  18         long long *tmp;
  19         int i = 0;
  20
  21         printf("(");
  22         FOR_EACH_PTR(list, tmp) {
  23                 if (i++)
  24                         printf(", ");
  25                 printf("%lld", *tmp);
  26         } END_FOR_EACH_PTR(tmp);
  27         printf(")\n");
  28 }
  29
  30 struct data_info *alloc_data_info(long long num)
  31 {
  32         struct data_info *ret;
  33
  34         ret = __alloc_data_info(0);
  35         ret->type = DATA_NUM;
  36         ret->merged = 0;
  37         ret->values = NULL;
  38         if (num != UNDEFINED)
  39                 add_num(&ret->values, num);
  40         return ret;
  41 }
  42
  43 void add_num(struct num_list **list, long long num)
  44 {
  45         long long *tmp;
  46         long long *new;
  47
  48         FOR_EACH_PTR(*list, tmp) {
  49                 if (*tmp < num)
  50                         continue;
  51                 else if (*tmp == num) {
  52                         return;
  53                 } else {
  54                         new = __alloc_sm_num(0);
  55                         *new = num;
  56                         INSERT_CURRENT(new, tmp);
  57                         return;
  58                 }
  59         } END_FOR_EACH_PTR(tmp);
  60         new = __alloc_sm_num(0);
  61         *new = num;
  62         add_ptr_list(list, new);
  63 }
  64
  65 struct num_list *num_list_union(struct num_list *one, struct num_list *two)
  66 {
  67         long long *tmp;
  68         struct num_list *ret = NULL;
  69
  70         if (!one || !two)
  71                 return NULL;
  72
  73         FOR_EACH_PTR(one, tmp) {
  74                 add_num(&ret, *tmp);
  75         } END_FOR_EACH_PTR(tmp);
  76         FOR_EACH_PTR(two, tmp) {
  77                 add_num(&ret, *tmp);
  78         } END_FOR_EACH_PTR(tmp);
  79         return ret;
  80 }
  81
  82 static int num_in_list(struct num_list *list, long long num)
  83 {
  84         long long *tmp;
  85
  86         FOR_EACH_PTR(list, tmp) {
  87                 if (*tmp == num)
  88                         return 1;
  89         } END_FOR_EACH_PTR(tmp);
  90         return 0;
  91 }
  92
  93 int num_matches(struct data_info *dinfo, long long num)
  94 {
  95         if (num_in_list(dinfo->values, num))
  96                 return 1;
  97         return 0;
  98 }
  99
 100 /*
 101  * if it can be only one value return that, else return UNDEFINED
 102  */
 103 long long get_single_value(struct data_info *dinfo)
 104 {
 105         long long *tmp;
 106         int count = 0;
 107         long long ret = UNDEFINED;
 108
 109         if (dinfo->type != DATA_NUM)
 110                 return UNDEFINED;
 111
 112         FOR_EACH_PTR(dinfo->values, tmp) {
 113                 if (!count++)
 114                         ret = *tmp;
 115                 else
 116                         return UNDEFINED;
 117         } END_FOR_EACH_PTR(tmp);
 118         return ret;
 119 }
 120
 121 int possibly_true(int comparison, struct data_info *dinfo, int num, int left)
 122 {
 123         long long *tmp;
 124         int ret = 0;
 125
 126         if (!dinfo->values)
 127                 return 1;
 128
 129         FOR_EACH_PTR(dinfo->values, tmp) {
 130                 if (left)
 131                         ret = true_comparison(*tmp, comparison, num);
 132                 else
 133                         ret = true_comparison(num,  comparison, *tmp);
 134                 if (ret)
 135                         return ret;
 136         } END_FOR_EACH_PTR(tmp);
 137         return ret;
 138 }
 139
 140 int possibly_false(int comparison, struct data_info *dinfo, int num, int left)
 141 {
 142         long long *tmp;
 143         int ret = 0;
 144
 145         if (!dinfo->values)
 146                 return 1;
 147
 148         FOR_EACH_PTR(dinfo->values, tmp) {
 149                 if (left)
 150                         ret = !true_comparison(*tmp, comparison, num);
 151                 else
 152                         ret = !true_comparison(num,  comparison, *tmp);
 153                 if (ret)
 154                         return ret;
 155         } END_FOR_EACH_PTR(tmp);
 156         return ret;
 157 }