Show
Ignore:
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.

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • lm-sensors/branches/lm-sensors-3.0.0/lib/access.c

    r4796 r4830  
    9090   Do not modify the struct the return value points to! Returns NULL if  
    9191   not found.*/ 
    92 const sensors_chip_feature *sensors_lookup_feature_nr(const sensors_chip_name *chip, 
     92const sensors_feature_data *sensors_lookup_feature_nr(const sensors_chip_name *chip, 
    9393                                                      int feature) 
    9494{ 
     
    108108   Do not modify the struct the return value points to! Returns NULL if  
    109109   not found.*/ 
    110 static const sensors_chip_feature * 
     110static const sensors_feature_data * 
    111111sensors_lookup_feature_name(const sensors_chip_name *chip, const char *feature) 
    112112{ 
    113113        int i, j; 
    114         const sensors_chip_feature *features; 
     114        const sensors_feature_data *features; 
    115115 
    116116        for (i = 0; i < sensors_proc_chips_count; i++) 
     
    118118                        features = sensors_proc_chips[i].feature; 
    119119                        for (j = 0; j < sensors_proc_chips[i].feature_count; j++) 
    120                                 if (!strcmp(features[j].data.name, feature)) 
     120                                if (!strcmp(features[j].name, feature)) 
    121121                                        return features + j; 
    122122                } 
     
    146146        char *label; 
    147147        const sensors_chip *chip; 
    148         const sensors_chip_feature *featureptr; 
     148        const sensors_feature_data *featureptr; 
    149149        char buf[128], path[PATH_MAX]; 
    150150        FILE *f; 
     
    158158        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
    159159                for (i = 0; i < chip->labels_count; i++) 
    160                         if (!strcmp(featureptr->data.name, chip->labels[i].name)) { 
     160                        if (!strcmp(featureptr->name, chip->labels[i].name)) { 
    161161                                label = strdup(chip->labels[i].value); 
    162162                                goto sensors_get_label_exit; 
     
    165165        /* No user specified label, check for a _label sysfs file */ 
    166166        snprintf(path, PATH_MAX, "%s/%s_label", name->path, 
    167                 featureptr->data.name); 
     167                featureptr->name); 
    168168         
    169169        if ((f = fopen(path, "r"))) { 
     
    179179 
    180180        /* No label, return the feature name instead */ 
    181         label = strdup(featureptr->data.name); 
     181        label = strdup(featureptr->name); 
    182182         
    183183sensors_get_label_exit: 
     
    192192   mappings into account. */ 
    193193static int sensors_get_ignored(const sensors_chip_name *name, 
    194                                const sensors_chip_feature *feature) 
     194                               const sensors_feature_data *feature) 
    195195{ 
    196196        const sensors_chip *chip; 
     
    198198        int i; 
    199199 
    200         if (feature->data.mapping == SENSORS_NO_MAPPING) 
     200        if (feature->mapping == SENSORS_NO_MAPPING) 
    201201                main_feature_name = NULL; 
    202202        else 
    203203                main_feature_name = sensors_lookup_feature_nr(name, 
    204                                         feature->data.mapping)->data.name; 
     204                                        feature->mapping)->name; 
    205205 
    206206        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
    207207                for (i = 0; i < chip->ignores_count; i++) 
    208                         if (!strcmp(feature->data.name, chip->ignores[i].name) || 
     208                        if (!strcmp(feature->name, chip->ignores[i].name) || 
    209209                            (main_feature_name && 
    210210                             !strcmp(main_feature_name, chip->ignores[i].name))) 
     
    219219                      double *result) 
    220220{ 
    221         const sensors_chip_feature *main_feature; 
    222         const sensors_chip_feature *alt_feature; 
     221        const sensors_feature_data *main_feature; 
     222        const sensors_feature_data *alt_feature; 
    223223        const sensors_chip *chip; 
    224224        const sensors_expr *expr = NULL; 
     
    232232                return -SENSORS_ERR_NO_ENTRY; 
    233233 
    234         if (main_feature->data.flags & SENSORS_COMPUTE_MAPPING) 
     234        if (main_feature->flags & SENSORS_COMPUTE_MAPPING) 
    235235                alt_feature = sensors_lookup_feature_nr(name, 
    236                                         main_feature->data.mapping); 
     236                                        main_feature->mapping); 
    237237        else 
    238238                alt_feature = NULL; 
    239239 
    240         if (!(main_feature->data.flags & SENSORS_MODE_R)) 
     240        if (!(main_feature->flags & SENSORS_MODE_R)) 
    241241                return -SENSORS_ERR_ACCESS_R; 
    242242        for (chip = NULL; 
    243243             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
    244244                for (i = 0; !final_expr && (i < chip->computes_count); i++) { 
    245                         if (!strcmp(main_feature->data.name, chip->computes[i].name)) { 
     245                        if (!strcmp(main_feature->name, chip->computes[i].name)) { 
    246246                                expr = chip->computes[i].from_proc; 
    247247                                final_expr = 1; 
    248                         } else if (alt_feature && !strcmp(alt_feature->data.name, 
     248                        } else if (alt_feature && !strcmp(alt_feature->name, 
    249249                                               chip->computes[i].name)) { 
    250250                                expr = chip->computes[i].from_proc; 
     
    266266                      double value) 
    267267{ 
    268         const sensors_chip_feature *main_feature; 
    269         const sensors_chip_feature *alt_feature; 
     268        const sensors_feature_data *main_feature; 
     269        const sensors_feature_data *alt_feature; 
    270270        const sensors_chip *chip; 
    271271        const sensors_expr *expr = NULL; 
     
    279279                return -SENSORS_ERR_NO_ENTRY; 
    280280 
    281         if (main_feature->data.flags & SENSORS_COMPUTE_MAPPING) 
     281        if (main_feature->flags & SENSORS_COMPUTE_MAPPING) 
    282282                alt_feature = sensors_lookup_feature_nr(name, 
    283                                         main_feature->data.mapping); 
     283                                        main_feature->mapping); 
    284284        else 
    285285                alt_feature = NULL; 
    286286 
    287         if (!(main_feature->data.flags & SENSORS_MODE_W)) 
     287        if (!(main_feature->flags & SENSORS_MODE_W)) 
    288288                return -SENSORS_ERR_ACCESS_W; 
    289289        for (chip = NULL; 
    290290             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
    291291                for (i = 0; !final_expr && (i < chip->computes_count); i++) 
    292                         if (!strcmp(main_feature->data.name, chip->computes[i].name)) { 
     292                        if (!strcmp(main_feature->name, chip->computes[i].name)) { 
    293293                                expr = chip->computes->to_proc; 
    294294                                final_expr = 1; 
    295                         } else if (alt_feature && !strcmp(alt_feature->data.name, 
     295                        } else if (alt_feature && !strcmp(alt_feature->name, 
    296296                                               chip->computes[i].name)) { 
    297297                                expr = chip->computes[i].to_proc; 
     
    348348                                                     int *nr) 
    349349{ 
    350         sensors_chip_feature *feature_list; 
     350        sensors_feature_data *feature_list; 
    351351        int i; 
    352352 
     
    359359                        if (*nr == sensors_proc_chips[i].feature_count) 
    360360                                return NULL; 
    361                         return &feature_list[(*nr)++].data; 
     361                        return &feature_list[(*nr)++]; 
    362362                } 
    363363        return NULL; 
     
    371371        double res1, res2; 
    372372        int res; 
    373         const sensors_chip_feature *feature; 
     373        const sensors_feature_data *feature; 
    374374 
    375375        if (expr->kind == sensors_kind_val) { 
     
    385385                                                            expr->data.var))) 
    386386                        return SENSORS_ERR_NO_ENTRY; 
    387                 if (!(res = sensors_get_value(name, feature->data.number, result))) 
     387                if (!(res = sensors_get_value(name, feature->number, result))) 
    388388                        return res; 
    389389                return 0; 
     
    433433        int i, j; 
    434434        int err = 0, res; 
    435         const sensors_chip_feature *feature; 
     435        const sensors_feature_data *feature; 
    436436        int *feature_list = NULL; 
    437437        int feature_count = 0; 
     
    449449                                continue; 
    450450                        } 
    451                         feature_nr = feature->data.number; 
     451                        feature_nr = feature->number; 
    452452 
    453453                        /* Check whether we already set this feature */