Changeset 4830

Timestamp:

09/23/07 13:59:51 (6 years ago)

Author:

khali

Message:

sensors_feature_data and sensors_chip_feature are now the exact
same structure, so we can get rid of the former for simpler code.

Location:

lm-sensors/branches/lm-sensors-3.0.0/lib

Files:

• access.c (modified) (19 diffs)
• access.h (modified) (1 diff)
• data.h (modified) (1 diff)
• init.c (modified) (1 diff)
• sensors.h (modified) (1 diff)
• sysfs.c (modified) (12 diffs)

lm-sensors/branches/lm-sensors-3.0.0/lib/access.c

@@ -90 +90 @@
    Do not modify the struct the return value points to! Returns NULL if 
    not found.*/
-const sensors_chip_feature *sensors_lookup_feature_nr(const sensors_chip_name *chip,
+const sensors_feature_data *sensors_lookup_feature_nr(const sensors_chip_name *chip,
                                                       int feature)
 {
@@ -108 +108 @@
    Do not modify the struct the return value points to! Returns NULL if 
    not found.*/
-static const sensors_chip_feature *
+static const sensors_feature_data *
 sensors_lookup_feature_name(const sensors_chip_name *chip, const char *feature)
 {
         int i, j;
-        const sensors_chip_feature *features;
+        const sensors_feature_data *features;
 
         for (i = 0; i < sensors_proc_chips_count; i++)
@@ -118 +118 @@
                         features = sensors_proc_chips[i].feature;
                         for (j = 0; j < sensors_proc_chips[i].feature_count; j++)
-                                if (!strcmp(features[j].data.name, feature))
+                                if (!strcmp(features[j].name, feature))
                                         return features + j;
                 }
@@ -146 +146 @@
         char *label;
         const sensors_chip *chip;
-        const sensors_chip_feature *featureptr;
+        const sensors_feature_data *featureptr;
         char buf[128], path[PATH_MAX];
         FILE *f;
@@ -158 +158 @@
         for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));)
                 for (i = 0; i < chip->labels_count; i++)
-                        if (!strcmp(featureptr->data.name, chip->labels[i].name)) {
+                        if (!strcmp(featureptr->name, chip->labels[i].name)) {
                                 label = strdup(chip->labels[i].value);
                                 goto sensors_get_label_exit;
@@ -165 +165 @@
         /* No user specified label, check for a _label sysfs file */
         snprintf(path, PATH_MAX, "%s/%s_label", name->path,
-                featureptr->data.name);
+                featureptr->name);
         
         if ((f = fopen(path, "r"))) {
@@ -179 +179 @@
 
         /* No label, return the feature name instead */
-        label = strdup(featureptr->data.name);
+        label = strdup(featureptr->name);
         
 sensors_get_label_exit:
@@ -192 +192 @@
    mappings into account. */
 static int sensors_get_ignored(const sensors_chip_name *name,
-                               const sensors_chip_feature *feature)
+                               const sensors_feature_data *feature)
 {
         const sensors_chip *chip;
@@ -198 +198 @@
         int i;
 
-        if (feature->data.mapping == SENSORS_NO_MAPPING)
+        if (feature->mapping == SENSORS_NO_MAPPING)
                 main_feature_name = NULL;
         else
                 main_feature_name = sensors_lookup_feature_nr(name,
-                                        feature->data.mapping)->data.name;
+                                        feature->mapping)->name;
 
         for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));)
                 for (i = 0; i < chip->ignores_count; i++)
-                        if (!strcmp(feature->data.name, chip->ignores[i].name) ||
+                        if (!strcmp(feature->name, chip->ignores[i].name) ||
                             (main_feature_name &&
                              !strcmp(main_feature_name, chip->ignores[i].name)))
@@ -219 +219 @@
                       double *result)
 {
-        const sensors_chip_feature *main_feature;
-        const sensors_chip_feature *alt_feature;
+        const sensors_feature_data *main_feature;
+        const sensors_feature_data *alt_feature;
         const sensors_chip *chip;
         const sensors_expr *expr = NULL;
@@ -232 +232 @@
                 return -SENSORS_ERR_NO_ENTRY;
 
-        if (main_feature->data.flags & SENSORS_COMPUTE_MAPPING)
+        if (main_feature->flags & SENSORS_COMPUTE_MAPPING)
                 alt_feature = sensors_lookup_feature_nr(name,
-                                        main_feature->data.mapping);
+                                        main_feature->mapping);
         else
                 alt_feature = NULL;
 
-        if (!(main_feature->data.flags & SENSORS_MODE_R))
+        if (!(main_feature->flags & SENSORS_MODE_R))
                 return -SENSORS_ERR_ACCESS_R;
         for (chip = NULL;
              !expr && (chip = sensors_for_all_config_chips(name, chip));)
                 for (i = 0; !final_expr && (i < chip->computes_count); i++) {
-                        if (!strcmp(main_feature->data.name, chip->computes[i].name)) {
+                        if (!strcmp(main_feature->name, chip->computes[i].name)) {
                                 expr = chip->computes[i].from_proc;
                                 final_expr = 1;
-                        } else if (alt_feature && !strcmp(alt_feature->data.name,
+                        } else if (alt_feature && !strcmp(alt_feature->name,
                                                chip->computes[i].name)) {
                                 expr = chip->computes[i].from_proc;
@@ -266 +266 @@
                       double value)
 {
-        const sensors_chip_feature *main_feature;
-        const sensors_chip_feature *alt_feature;
+        const sensors_feature_data *main_feature;
+        const sensors_feature_data *alt_feature;
         const sensors_chip *chip;
         const sensors_expr *expr = NULL;
@@ -279 +279 @@
                 return -SENSORS_ERR_NO_ENTRY;
 
-        if (main_feature->data.flags & SENSORS_COMPUTE_MAPPING)
+        if (main_feature->flags & SENSORS_COMPUTE_MAPPING)
                 alt_feature = sensors_lookup_feature_nr(name,
-                                        main_feature->data.mapping);
+                                        main_feature->mapping);
         else
                 alt_feature = NULL;
 
-        if (!(main_feature->data.flags & SENSORS_MODE_W))
+        if (!(main_feature->flags & SENSORS_MODE_W))
                 return -SENSORS_ERR_ACCESS_W;
         for (chip = NULL;
              !expr && (chip = sensors_for_all_config_chips(name, chip));)
                 for (i = 0; !final_expr && (i < chip->computes_count); i++)
-                        if (!strcmp(main_feature->data.name, chip->computes[i].name)) {
+                        if (!strcmp(main_feature->name, chip->computes[i].name)) {
                                 expr = chip->computes->to_proc;
                                 final_expr = 1;
-                        } else if (alt_feature && !strcmp(alt_feature->data.name,
+                        } else if (alt_feature && !strcmp(alt_feature->name,
                                                chip->computes[i].name)) {
                                 expr = chip->computes[i].to_proc;
@@ -348 +348 @@
                                                      int *nr)
 {
-        sensors_chip_feature *feature_list;
+        sensors_feature_data *feature_list;
         int i;
 
@@ -359 +359 @@
                         if (*nr == sensors_proc_chips[i].feature_count)
                                 return NULL;
-                        return &feature_list[(*nr)++].data;
+                        return &feature_list[(*nr)++];
                 }
         return NULL;
@@ -371 +371 @@
         double res1, res2;
         int res;
-        const sensors_chip_feature *feature;
+        const sensors_feature_data *feature;
 
         if (expr->kind == sensors_kind_val) {
@@ -385 +385 @@
                                                             expr->data.var)))
                         return SENSORS_ERR_NO_ENTRY;
-                if (!(res = sensors_get_value(name, feature->data.number, result)))
+                if (!(res = sensors_get_value(name, feature->number, result)))
                         return res;
                 return 0;
@@ -433 +433 @@
         int i, j;
         int err = 0, res;
-        const sensors_chip_feature *feature;
+        const sensors_feature_data *feature;
         int *feature_list = NULL;
         int feature_count = 0;
@@ -449 +449 @@
                                 continue;
                         }
-                        feature_nr = feature->data.number;
+                        feature_nr = feature->number;
 
                         /* Check whether we already set this feature */

lm-sensors/branches/lm-sensors-3.0.0/lib/access.h

@@ -27 +27 @@
    Do not modify the struct the return value points to! Returns NULL if
    not found. */
-const sensors_chip_feature *sensors_lookup_feature_nr(const sensors_chip_name *chip,
+const sensors_feature_data *sensors_lookup_feature_nr(const sensors_chip_name *chip,
                                                       int feature);
 

lm-sensors/branches/lm-sensors-3.0.0/lib/data.h

@@ -121 +121 @@
 } sensors_bus;
 
-/* Internal data about a single chip feature.
-   name is the string name used to refer to this feature (both in config
-     files and through user functions);
-   number is the internal feature number, used in many functions to refer
-     to this feature
-   mapping is either SENSORS_NO_MAPPING if this is feature is the
-     main element of category; or it is the number of a feature with which
-     this feature is logically grouped (a group could be fan, fan_max and
-     fan_div)
-   flags is a bitfield, its value is a combination of SENSORS_MODE_R (readable),
-     SENSORS_MODE_W (writable) and SENSORS_COMPUTE_MAPPING (affected by the
-     computation rules of the main feature). */
-typedef struct sensors_chip_feature {
-        sensors_feature_data data;
-} sensors_chip_feature;
-
 /* Internal data about all features of a type of chip */
 typedef struct sensors_chip_features {
         struct sensors_chip_name chip;
-        struct sensors_chip_feature *feature;
+        struct sensors_feature_data *feature;
         int feature_count;
 } sensors_chip_features;

lm-sensors/branches/lm-sensors-3.0.0/lib/init.c

@@ -58 +58 @@
 
         for (i = 0; i < features->feature_count; i++)
-                free(features->feature[i].data.name);
+                free(features->feature[i].name);
         free(features->feature);
 }

lm-sensors/branches/lm-sensors-3.0.0/lib/sensors.h

@@ -164 +164 @@
 } sensors_feature_type;
 
-/* This structure is used when you want to get all features of a specific
-   chip. */
+/* Data about a single chip feature:
+   name is the string name used to refer to this feature (in config files)
+   number is the internal feature number, used in many functions to refer
+     to this feature
+   type is the feature or subfeature type
+   mapping is either SENSORS_NO_MAPPING if this is feature is the
+     main element of category; or it is the number of a feature with which
+     this subfeature is logically grouped (a group could be fan, fan_min
+     and fan_div)
+   flags is a bitfield, its value is a combination of SENSORS_MODE_R (readable),
+     SENSORS_MODE_W (writable) and SENSORS_COMPUTE_MAPPING (affected by the
+     computation rules of the main feature) */
 typedef struct sensors_feature_data {
         char *name;

lm-sensors/branches/lm-sensors-3.0.0/lib/sysfs.c

@@ -162 +162 @@
         struct sysfs_attribute *attr;
         struct dlist *attrs;
-        sensors_chip_feature *features;
-        sensors_chip_feature *dyn_features;
+        sensors_feature_data *features;
+        sensors_feature_data *dyn_features;
 
         attrs = sysfs_get_device_attributes(sysdir);
@@ -173 +173 @@
            so that we can store them sorted at type and index and then later
            create a dense sorted table. */
-        features = calloc(ALL_POSSIBLE_FEATURES, sizeof(sensors_chip_feature));
+        features = calloc(ALL_POSSIBLE_FEATURES, sizeof(sensors_feature_data));
         if (!features)
                 sensors_fatal_error(__FUNCTION__, "Out of memory");
@@ -218 +218 @@
                 }
 
-                if (features[i].data.name) {
+                if (features[i].name) {
                         fprintf(stderr, "libsensors error, trying to add dupli"
                                 "cate feature: %s to dynamic feature table\n",
@@ -226 +226 @@
 
                 /* fill in the feature members */
-                features[i].data.type = type;
+                features[i].type = type;
 
                 /* check for _input extension and remove */
                 nr = strlen(name);
                 if (nr > 6 && !strcmp(name + nr - 6, "_input"))
-                        features[i].data.name = strndup(name, nr - 6);
+                        features[i].name = strndup(name, nr - 6);
                 else
-                        features[i].data.name = strdup(name);
+                        features[i].name = strdup(name);
 
                 if ((type & 0x00FF) == 0) {
                         /* main feature */
-                        features[i].data.mapping = SENSORS_NO_MAPPING;
+                        features[i].mapping = SENSORS_NO_MAPPING;
                 } else {
                         /* sub feature */
                         /* The mapping is set below after numbering */
                         if (!(type & 0x10))
-                                features[i].data.flags |= SENSORS_COMPUTE_MAPPING;
+                                features[i].flags |= SENSORS_COMPUTE_MAPPING;
                 }
 
                 if (attr->method & SYSFS_METHOD_SHOW)
-                        features[i].data.flags |= SENSORS_MODE_R;
+                        features[i].flags |= SENSORS_MODE_R;
                 if (attr->method & SYSFS_METHOD_STORE)
-                        features[i].data.flags |= SENSORS_MODE_W;
+                        features[i].flags |= SENSORS_MODE_W;
 
                 fnum++;
@@ -258 +258 @@
         }
 
-        dyn_features = calloc(fnum, sizeof(sensors_chip_feature));
+        dyn_features = calloc(fnum, sizeof(sensors_feature_data));
         if (dyn_features == NULL) {
                 sensors_fatal_error(__FUNCTION__, "Out of memory");
@@ -265 +265 @@
         fnum = 0;
         for (i = 0; i < ALL_POSSIBLE_FEATURES; i++) {
-                if (features[i].data.name) {
+                if (features[i].name) {
                         dyn_features[fnum] = features[i];
                         fnum++;
@@ -276 +276 @@
                 int j;
 
-                dyn_features[i].data.number = i;
-                if (dyn_features[i].data.mapping == SENSORS_NO_MAPPING) {
+                dyn_features[i].number = i;
+                if (dyn_features[i].mapping == SENSORS_NO_MAPPING) {
                         /* Main feature, set the mapping field of all its
                            subfeatures */
                         for (j = i + 1; j < fnum &&
-                             dyn_features[j].data.mapping != SENSORS_NO_MAPPING;
+                             dyn_features[j].mapping != SENSORS_NO_MAPPING;
                              j++)
-                                dyn_features[j].data.mapping = i;
+                                dyn_features[j].mapping = i;
                 }
         }
@@ -514 +514 @@
                             double *value)
 {
-        const sensors_chip_feature *the_feature;
+        const sensors_feature_data *the_feature;
         char n[NAME_MAX];
         FILE *f;
@@ -523 +523 @@
 
         /* REVISIT: this is a ugly hack */
-        if (the_feature->data.type == SENSORS_FEATURE_IN
-         || the_feature->data.type == SENSORS_FEATURE_FAN
-         || the_feature->data.type == SENSORS_FEATURE_TEMP)
+        if (the_feature->type == SENSORS_FEATURE_IN
+         || the_feature->type == SENSORS_FEATURE_FAN
+         || the_feature->type == SENSORS_FEATURE_TEMP)
                 suffix = "_input";
 
-        snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->data.name,
+        snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->name,
                  suffix);
         if ((f = fopen(n, "r"))) {
@@ -535 +535 @@
                 if (res != 1)
                         return -SENSORS_ERR_PROC;
-                *value /= get_type_scaling(the_feature->data.type);
+                *value /= get_type_scaling(the_feature->type);
         } else
                 return -SENSORS_ERR_PROC;
@@ -545 +545 @@
                              double value)
 {
-        const sensors_chip_feature *the_feature;
+        const sensors_feature_data *the_feature;
         char n[NAME_MAX];
         FILE *f;
@@ -554 +554 @@
 
         /* REVISIT: this is a ugly hack */
-        if (the_feature->data.type == SENSORS_FEATURE_IN
-         || the_feature->data.type == SENSORS_FEATURE_FAN
-         || the_feature->data.type == SENSORS_FEATURE_TEMP)
+        if (the_feature->type == SENSORS_FEATURE_IN
+         || the_feature->type == SENSORS_FEATURE_FAN
+         || the_feature->type == SENSORS_FEATURE_TEMP)
                 suffix = "_input";
 
-        snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->data.name,
+        snprintf(n, NAME_MAX, "%s/%s%s", name->path, the_feature->name,
                  suffix);
         if ((f = fopen(n, "w"))) {
-                value *= get_type_scaling(the_feature->data.type);
+                value *= get_type_scaling(the_feature->type);
                 fprintf(f, "%d", (int) value);
                 fclose(f);