| 30 | | static void free_chip_name(sensors_chip_name *name); |
| 31 | | static void free_chip_features(sensors_chip_feature *features); |
| 32 | | static void free_bus(sensors_bus *bus); |
| 33 | | static void free_chip(sensors_chip *chip); |
| 34 | | static void free_label(sensors_label *label); |
| 35 | | static void free_set(sensors_set *set); |
| 36 | | static void free_compute(sensors_compute *compute); |
| 37 | | static void free_ignore(sensors_ignore *ignore); |
| 38 | | static void free_expr(sensors_expr *expr); |
| 39 | | |
| | 46 | } |
| | 47 | |
| | 48 | static void free_chip_name(sensors_chip_name *name) |
| | 49 | { |
| | 50 | free(name->prefix); |
| | 51 | free(name->path); |
| | 52 | } |
| | 53 | |
| | 54 | static void free_chip_features(sensors_chip_feature *features) |
| | 55 | { |
| | 56 | int i; |
| | 57 | |
| | 58 | for (i = 0; features[i].data.name; i++) |
| | 59 | free(features[i].data.name); |
| | 60 | free(features); |
| | 61 | } |
| | 62 | |
| | 63 | static void free_bus(sensors_bus *bus) |
| | 64 | { |
| | 65 | free(bus->adapter); |
| | 66 | } |
| | 67 | |
| | 68 | static void free_label(sensors_label *label) |
| | 69 | { |
| | 70 | free(label->name); |
| | 71 | free(label->value); |
| | 72 | } |
| | 73 | |
| | 74 | static void free_expr(sensors_expr *expr) |
| | 75 | { |
| | 76 | if (expr->kind == sensors_kind_var) |
| | 77 | free(expr->data.var); |
| | 78 | else if (expr->kind == sensors_kind_sub) { |
| | 79 | if (expr->data.subexpr.sub1) |
| | 80 | free_expr(expr->data.subexpr.sub1); |
| | 81 | if (expr->data.subexpr.sub2) |
| | 82 | free_expr(expr->data.subexpr.sub2); |
| | 83 | } |
| | 84 | free(expr); |
| | 85 | } |
| | 86 | |
| | 87 | static void free_set(sensors_set *set) |
| | 88 | { |
| | 89 | free(set->name); |
| | 90 | free_expr(set->value); |
| | 91 | } |
| | 92 | |
| | 93 | static void free_compute(sensors_compute *compute) |
| | 94 | { |
| | 95 | free(compute->name); |
| | 96 | free_expr(compute->from_proc); |
| | 97 | free_expr(compute->to_proc); |
| | 98 | } |
| | 99 | |
| | 100 | static void free_ignore(sensors_ignore *ignore) |
| | 101 | { |
| | 102 | free(ignore->name); |
| | 103 | } |
| | 104 | |
| | 105 | static void free_chip(sensors_chip *chip) |
| | 106 | { |
| | 107 | int i; |
| | 108 | |
| | 109 | for (i = 0; i < chip->chips.fits_count; i++) |
| | 110 | free_chip_name(&chip->chips.fits[i]); |
| | 111 | free(chip->chips.fits); |
| | 112 | chip->chips.fits_count = chip->chips.fits_max = 0; |
| | 113 | |
| | 114 | for (i = 0; i < chip->labels_count; i++) |
| | 115 | free_label(&chip->labels[i]); |
| | 116 | free(chip->labels); |
| | 117 | chip->labels_count = chip->labels_max = 0; |
| | 118 | |
| | 119 | for (i = 0; i < chip->sets_count; i++) |
| | 120 | free_set(&chip->sets[i]); |
| | 121 | free(chip->sets); |
| | 122 | chip->sets_count = chip->sets_max = 0; |
| | 123 | |
| | 124 | for (i = 0; i < chip->computes_count; i++) |
| | 125 | free_compute(&chip->computes[i]); |
| | 126 | free(chip->computes); |
| | 127 | chip->computes_count = chip->computes_max = 0; |
| | 128 | |
| | 129 | for (i = 0; i < chip->ignores_count; i++) |
| | 130 | free_ignore(&chip->ignores[i]); |
| | 131 | free(chip->ignores); |
| | 132 | chip->ignores_count = chip->ignores_max = 0; |
| 90 | | |
| 91 | | void free_chip_name(sensors_chip_name *name) |
| 92 | | { |
| 93 | | free(name->prefix); |
| 94 | | free(name->path); |
| 95 | | } |
| 96 | | |
| 97 | | void free_chip_features(sensors_chip_feature *features) |
| 98 | | { |
| 99 | | int i; |
| 100 | | |
| 101 | | for (i = 0; features[i].data.name; i++) |
| 102 | | free(features[i].data.name); |
| 103 | | free(features); |
| 104 | | } |
| 105 | | |
| 106 | | void free_bus(sensors_bus *bus) |
| 107 | | { |
| 108 | | free(bus->adapter); |
| 109 | | } |
| 110 | | |
| 111 | | void free_chip(sensors_chip *chip) |
| 112 | | { |
| 113 | | int i; |
| 114 | | |
| 115 | | for (i = 0; i < chip->chips.fits_count; i++) |
| 116 | | free_chip_name(&chip->chips.fits[i]); |
| 117 | | free(chip->chips.fits); |
| 118 | | chip->chips.fits_count = chip->chips.fits_max = 0; |
| 119 | | |
| 120 | | for (i = 0; i < chip->labels_count; i++) |
| 121 | | free_label(&chip->labels[i]); |
| 122 | | free(chip->labels); |
| 123 | | chip->labels_count = chip->labels_max = 0; |
| 124 | | |
| 125 | | for (i = 0; i < chip->sets_count; i++) |
| 126 | | free_set(&chip->sets[i]); |
| 127 | | free(chip->sets); |
| 128 | | chip->sets_count = chip->sets_max = 0; |
| 129 | | |
| 130 | | for (i = 0; i < chip->computes_count; i++) |
| 131 | | free_compute(&chip->computes[i]); |
| 132 | | free(chip->computes); |
| 133 | | chip->computes_count = chip->computes_max = 0; |
| 134 | | |
| 135 | | for (i = 0; i < chip->ignores_count; i++) |
| 136 | | free_ignore(&chip->ignores[i]); |
| 137 | | free(chip->ignores); |
| 138 | | chip->ignores_count = chip->ignores_max = 0; |
| 139 | | } |
| 140 | | |
| 141 | | void free_label(sensors_label *label) |
| 142 | | { |
| 143 | | free(label->name); |
| 144 | | free(label->value); |
| 145 | | } |
| 146 | | |
| 147 | | void free_set(sensors_set *set) |
| 148 | | { |
| 149 | | free(set->name); |
| 150 | | free_expr(set->value); |
| 151 | | } |
| 152 | | |
| 153 | | void free_compute(sensors_compute *compute) |
| 154 | | { |
| 155 | | free(compute->name); |
| 156 | | free_expr(compute->from_proc); |
| 157 | | free_expr(compute->to_proc); |
| 158 | | } |
| 159 | | |
| 160 | | void free_ignore(sensors_ignore *ignore) |
| 161 | | { |
| 162 | | free(ignore->name); |
| 163 | | } |
| 164 | | |
| 165 | | void free_expr(sensors_expr *expr) |
| 166 | | { |
| 167 | | if ((expr->kind) == sensors_kind_var) |
| 168 | | free(expr->data.var); |
| 169 | | else if ((expr->kind) == sensors_kind_sub) { |
| 170 | | if (expr->data.subexpr.sub1) |
| 171 | | free_expr(expr->data.subexpr.sub1); |
| 172 | | if (expr->data.subexpr.sub2) |
| 173 | | free_expr(expr->data.subexpr.sub2); |
| 174 | | } |
| 175 | | free(expr); |
| 176 | | } |