Changeset 4073

Show
Ignore:
Timestamp:
07/25/06 04:12:37 (2 years ago)
Author:
mmh
Message:

Reformat of lib/access.c:

First ran .../scripts/Lindent from Linux 2.6.x, then fixed up some
things that were particularly ugly. Verified the final result by
rebuilding and running 'objdump -d' on the before and after; there
were no differences.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • lm-sensors/trunk/lib/access.c

    r3113 r4073  
    3434int sensors_match_chip(sensors_chip_name chip1, sensors_chip_name chip2) 
    3535{ 
    36   if ((chip1.prefix != SENSORS_CHIP_NAME_PREFIX_ANY) && 
    37       (chip2.prefix != SENSORS_CHIP_NAME_PREFIX_ANY) && 
    38       strcasecmp(chip1.prefix,chip2.prefix)) 
    39     return 0; 
    40   if ((chip1.bus != SENSORS_CHIP_NAME_BUS_ANY) &&  
    41       (chip2.bus != SENSORS_CHIP_NAME_BUS_ANY) && 
    42       (chip1.bus != chip2.bus)) { 
    43     if ((chip1.bus == SENSORS_CHIP_NAME_BUS_ISA) || 
    44         (chip2.bus == SENSORS_CHIP_NAME_BUS_ISA)) 
    45       return 0; 
    46     if ((chip1.bus != SENSORS_CHIP_NAME_BUS_ANY_I2C) && 
    47         (chip2.bus != SENSORS_CHIP_NAME_BUS_ANY_I2C)) 
    48       return 0; 
    49   } 
    50   if ((chip1.addr != chip2.addr) && 
    51       (chip1.addr != SENSORS_CHIP_NAME_ADDR_ANY) && 
    52       (chip2.addr != SENSORS_CHIP_NAME_ADDR_ANY)) 
    53     return 0; 
    54   return 1; 
     36        if ((chip1.prefix != SENSORS_CHIP_NAME_PREFIX_ANY) && 
     37            (chip2.prefix != SENSORS_CHIP_NAME_PREFIX_ANY) && 
     38            strcasecmp(chip1.prefix, chip2.prefix)) 
     39                return 0; 
     40 
     41        if ((chip1.bus != SENSORS_CHIP_NAME_BUS_ANY) && 
     42            (chip2.bus != SENSORS_CHIP_NAME_BUS_ANY) && 
     43            (chip1.bus != chip2.bus)) { 
     44 
     45                if ((chip1.bus == SENSORS_CHIP_NAME_BUS_ISA) || 
     46                    (chip2.bus == SENSORS_CHIP_NAME_BUS_ISA)) 
     47                        return 0; 
     48 
     49                if ((chip1.bus != SENSORS_CHIP_NAME_BUS_ANY_I2C) && 
     50                    (chip2.bus != SENSORS_CHIP_NAME_BUS_ANY_I2C)) 
     51                        return 0; 
     52        } 
     53 
     54        if ((chip1.addr != chip2.addr) && 
     55            (chip1.addr != SENSORS_CHIP_NAME_ADDR_ANY) && 
     56            (chip2.addr != SENSORS_CHIP_NAME_ADDR_ANY)) 
     57                return 0; 
     58 
     59        return 1; 
    5560} 
    5661 
    …… 
    6267   Note that this visits the list of chips from last to first. Usually, 
    6368   you want the match that was latest in the config file. */ 
    64 sensors_chip *sensors_for_all_config_chips(sensors_chip_name chip_name,  
    65                                            const sensors_chip *last) 
    66 { 
    67   int nr,i; 
    68   sensors_chip_name_list chips; 
    69  
    70   for (nr = last?(last-sensors_config_chips)-1:sensors_config_chips_count-1;  
    71        nr >= 0; nr--) { 
    72     chips = sensors_config_chips[nr].chips; 
    73     for (i =0; i < chips.fits_count; i++) { 
    74       if (sensors_match_chip(chips.fits[i],chip_name)) 
    75         return sensors_config_chips+nr; 
    76     } 
    77   } 
    78   return NULL; 
     69sensors_chip *sensors_for_all_config_chips(sensors_chip_name chip_name, 
     70                                           const sensors_chip * last) 
     71{ 
     72        int nr, i; 
     73        sensors_chip_name_list chips; 
     74 
     75        for (nr = last ? last - sensors_config_chips - 1 : 
     76                         sensors_config_chips_count - 1; nr >= 0; nr--) { 
     77 
     78                chips = sensors_config_chips[nr].chips; 
     79                for (i = 0; i < chips.fits_count; i++) { 
     80                        if (sensors_match_chip(chips.fits[i], chip_name)) 
     81                                return sensors_config_chips + nr; 
     82                } 
     83        } 
     84        return NULL; 
    7985} 
    8086 
    …… 
    8288   Do not modify the struct the return value points to! Returns NULL if  
    8389   not found.*/ 
    84 const sensors_chip_feature *sensors_lookup_feature_nr(const char *prefix,  
    85                                                       int feature) 
    86 { 
    87   int i,j; 
    88   const sensors_chip_feature *features; 
    89   for (i = 0; sensors_chip_features_list[i].prefix; i++) 
    90     if (!strcasecmp(sensors_chip_features_list[i].prefix,prefix)) { 
    91       features = sensors_chip_features_list[i].feature; 
    92       for (j=0;  features[j].name; j++)  
    93         if (features[j].number == feature) 
    94           return features + j; 
    95     } 
    96   return NULL; 
     90const sensors_chip_feature *sensors_lookup_feature_nr(const char *prefix, 
     91                                                      int feature) 
     92{ 
     93        int i, j; 
     94        const sensors_chip_feature *features; 
     95 
     96        for (i = 0; sensors_chip_features_list[i].prefix; i++) 
     97                if (!strcasecmp(sensors_chip_features_list[i].prefix, prefix)) { 
     98                        features = sensors_chip_features_list[i].feature; 
     99                        for (j = 0; features[j].name; j++) 
     100                                if (features[j].number == feature) 
     101                                        return features + j; 
     102                } 
     103        return NULL; 
    97104} 
    98105 
    …… 
    101108   not found.*/ 
    102109const sensors_chip_feature *sensors_lookup_feature_name(const char *prefix, 
    103                                                         const char *feature) 
    104 { 
    105   int i,j; 
    106   const sensors_chip_feature *features; 
    107   for (i = 0; sensors_chip_features_list[i].prefix; i++) 
    108     if (!strcasecmp(sensors_chip_features_list[i].prefix,prefix)) { 
    109       features = sensors_chip_features_list[i].feature; 
    110       for (j=0;  features[j].name; j++)  
    111         if (!strcasecmp(features[j].name,feature)) 
    112           return features + j; 
    113     } 
    114   return NULL; 
    115 } 
    116  
     110                                                       const char *feature) 
     111{ 
     112       int i, j; 
     113       const sensors_chip_feature *features; 
     114 
     115        for (i = 0; sensors_chip_features_list[i].prefix; i++) 
     116                if (!strcasecmp(sensors_chip_features_list[i].prefix, prefix)) { 
     117                        features = sensors_chip_features_list[i].feature; 
     118                       for (j = 0; features[j].name; j++) 
     119                                if (!strcasecmp(features[j].name, feature)) 
     120                                        return features + j; 
     121                } 
     122        return NULL; 
     123} 
    117124 
    118125/* Check whether the chip name is an 'absolute' name, which can only match 
    …… 
    121128int sensors_chip_name_has_wildcards(sensors_chip_name chip) 
    122129{ 
    123   if ((chip.prefix == SENSORS_CHIP_NAME_PREFIX_ANY) || 
    124       (chip.bus == SENSORS_CHIP_NAME_BUS_ANY) || 
    125       (chip.bus == SENSORS_CHIP_NAME_BUS_ANY_I2C) || 
    126       (chip.addr == SENSORS_CHIP_NAME_ADDR_ANY)) 
    127     return 1; 
    128   else 
    129     return 0; 
     130       if ((chip.prefix == SENSORS_CHIP_NAME_PREFIX_ANY) || 
     131           (chip.bus == SENSORS_CHIP_NAME_BUS_ANY) || 
     132           (chip.bus == SENSORS_CHIP_NAME_BUS_ANY_I2C) || 
     133           (chip.addr == SENSORS_CHIP_NAME_ADDR_ANY)) 
     134               return 1; 
     135       else 
     136               return 0; 
    130137} 
    131138 
    …… 
    133140   contain wildcard values! *result is newly allocated (free it yourself). 
    134141   This function will return 0 on success, and <0 on failure. 
    135    If no label exists for this feature, its name is returned itself. */   
     142   If no label exists for this feature, its name is returned itself. */ 
    136143int sensors_get_label(sensors_chip_name name, int feature, char **result) 
    137144{ 
    138   const sensors_chip *chip; 
    139   const sensors_chip_feature *featureptr; 
    140   int i; 
    141  
    142   *result=NULL; 
    143   if (sensors_chip_name_has_wildcards(name)) 
    144     return -SENSORS_ERR_WILDCARDS; 
    145   if (! (featureptr = sensors_lookup_feature_nr(name.prefix,feature))) 
    146     return -SENSORS_ERR_NO_ENTRY; 
    147  
    148   for (chip = NULL; (chip = sensors_for_all_config_chips(name,chip));) 
    149     for (i = 0; i < chip->labels_count; i++) 
    150       if (!strcasecmp(featureptr->name, chip->labels[i].name)) { 
    151         if (*result) 
    152           free(*result); 
    153         if (! (*result = strdup(chip->labels[i].value))) 
    154           sensors_fatal_error("sensors_get_label","Allocating label text"); 
    155         return 0; 
    156       } 
    157  
    158   /* No label, return the feature name instead */ 
    159   if (! (*result = strdup(featureptr->name))) 
    160     sensors_fatal_error("sensors_get_label","Allocating label text"); 
    161   return 0; 
     145        const sensors_chip *chip; 
     146        const sensors_chip_feature *featureptr; 
     147        int i; 
     148 
     149        *result = NULL; 
     150        if (sensors_chip_name_has_wildcards(name)) 
     151                return -SENSORS_ERR_WILDCARDS; 
     152        if (!(featureptr = sensors_lookup_feature_nr(name.prefix, feature))) 
     153                return -SENSORS_ERR_NO_ENTRY; 
     154 
     155        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
     156                for (i = 0; i < chip->labels_count; i++) 
     157                        if (!strcasecmp(featureptr->name,chip->labels[i].name)){ 
     158                                if (*result) 
     159                                        free(*result); 
     160                                if (!(*result = strdup(chip->labels[i].value))) 
     161                                        sensors_fatal_error("sensors_get_label", 
     162                                                            "Allocating label text"); 
     163                                return 0; 
     164                        } 
     165 
     166        /* No label, return the feature name instead */ 
     167        if (!(*result = strdup(featureptr->name))) 
     168                sensors_fatal_error("sensors_get_label", 
     169                                    "Allocating label text"); 
     170        return 0; 
    162171} 
    163172 
    164173int sensors_get_ignored(sensors_chip_name name, int feature) 
    165174{ 
    166   const sensors_chip *chip; 
    167   const sensors_chip_feature *featureptr; 
    168   const sensors_chip_feature *alt_featureptr; 
    169   int i,res; 
    170  
    171   res = 1; /* Default: valid */ 
    172   if (sensors_chip_name_has_wildcards(name)) 
    173     return -SENSORS_ERR_WILDCARDS; 
    174   if (! (featureptr = sensors_lookup_feature_nr(name.prefix,feature))) 
    175     return -SENSORS_ERR_NO_ENTRY; 
    176   if (featureptr->logical_mapping == SENSORS_NO_MAPPING) 
    177     alt_featureptr = NULL; 
    178   else if (! (alt_featureptr = 
    179                    sensors_lookup_feature_nr(name.prefix, 
    180                                              featureptr->logical_mapping))) 
    181     return -SENSORS_ERR_NO_ENTRY; 
    182   for (chip = NULL; (chip = sensors_for_all_config_chips(name,chip));) 
    183     for (i = 0; i < chip->ignores_count; i++) 
    184       if (!strcasecmp(featureptr->name, chip->ignores[i].name)) 
    185         return 0; /* Exact match always overrules! */ 
    186       else if (alt_featureptr && 
    187                !strcasecmp(alt_featureptr->name, chip->ignores[i].name)) 
    188         res = 0; 
    189   return res; 
     175        const sensors_chip *chip; 
     176        const sensors_chip_feature *featureptr; 
     177        const sensors_chip_feature *alt_featureptr; 
     178        int i, res; 
     179 
     180        /* Default: valid */ 
     181        res = 1; 
     182        if (sensors_chip_name_has_wildcards(name)) 
     183                return -SENSORS_ERR_WILDCARDS; 
     184        if (!(featureptr = sensors_lookup_feature_nr(name.prefix, feature))) 
     185                return -SENSORS_ERR_NO_ENTRY; 
     186        if (featureptr->logical_mapping == SENSORS_NO_MAPPING) 
     187                alt_featureptr = NULL; 
     188        else if (!(alt_featureptr = 
     189                   sensors_lookup_feature_nr(name.prefix, 
     190                                             featureptr->logical_mapping))) 
     191                return -SENSORS_ERR_NO_ENTRY; 
     192        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
     193                for (i = 0; i < chip->ignores_count; i++) 
     194                        if (!strcasecmp(featureptr->name, chip->ignores[i].name)) 
     195                                return 0; /* Exact match always overrules! */ 
     196                        else if (alt_featureptr && 
     197                                 !strcasecmp(alt_featureptr->name, 
     198                                             chip->ignores[i].name)) 
     199                                res = 0; 
     200        return res; 
    190201} 
    191202 
    …… 
    195206int sensors_get_feature(sensors_chip_name name, int feature, double *result) 
    196207{ 
    197   const sensors_chip_feature *main_feature; 
    198   const sensors_chip_feature *alt_feature; 
    199   const sensors_chip *chip; 
    200   const sensors_expr *expr = NULL; 
    201   double val; 
    202   int res,i; 
    203   int final_expr=0; 
    204  
    205   if (sensors_chip_name_has_wildcards(name)) 
    206     return -SENSORS_ERR_WILDCARDS; 
    207   if (! (main_feature = sensors_lookup_feature_nr(name.prefix,feature))) 
    208     return -SENSORS_ERR_NO_ENTRY; 
    209   if (main_feature->compute_mapping == SENSORS_NO_MAPPING) 
    210     alt_feature = NULL; 
    211   else if (! (alt_feature = 
    212                    sensors_lookup_feature_nr(name.prefix, 
    213                                              main_feature->compute_mapping))) 
    214     return -SENSORS_ERR_NO_ENTRY; 
    215   if (! (main_feature->mode & SENSORS_MODE_R)) 
    216     return -SENSORS_ERR_ACCESS_R; 
    217   for (chip = NULL; !expr && (chip = sensors_for_all_config_chips(name,chip));) 
    218     for (i = 0; !final_expr && (i < chip->computes_count); i++) { 
    219       if (!strcasecmp(main_feature->name,chip->computes[i].name)) { 
    220         expr = chip->computes[i].from_proc; 
    221         final_expr = 1; 
    222       } else if (alt_feature &&  
    223                  !strcasecmp(alt_feature->name,chip->computes[i].name)) 
    224         expr = chip->computes[i].from_proc; 
    225     } 
    226   if (sensors_read_proc(name,feature,&val)) 
    227     return -SENSORS_ERR_PROC; 
    228   if (! expr) 
    229     *result = val; 
    230   else if ((res = sensors_eval_expr(name,expr,val,result))) 
    231     return res; 
    232   return 0; 
    233 } 
    234        
     208        const sensors_chip_feature *main_feature; 
     209        const sensors_chip_feature *alt_feature; 
     210        const sensors_chip *chip; 
     211        const sensors_expr *expr = NULL; 
     212        double val; 
     213        int res, i; 
     214        int final_expr = 0; 
     215 
     216        if (sensors_chip_name_has_wildcards(name)) 
     217                return -SENSORS_ERR_WILDCARDS; 
     218        if (!(main_feature = sensors_lookup_feature_nr(name.prefix, feature))) 
     219                return -SENSORS_ERR_NO_ENTRY; 
     220        if (main_feature->compute_mapping == SENSORS_NO_MAPPING) 
     221                alt_feature = NULL; 
     222        else if (!(alt_feature = sensors_lookup_feature_nr(name.prefix, 
     223                                        main_feature->compute_mapping))) 
     224                return -SENSORS_ERR_NO_ENTRY; 
     225        if (!(main_feature->mode & SENSORS_MODE_R)) 
     226                return -SENSORS_ERR_ACCESS_R; 
     227        for (chip = NULL; 
     228             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
     229                for (i = 0; !final_expr && (i < chip->computes_count); i++) { 
     230                        if (!strcasecmp(main_feature->name, chip->computes[i].name)) { 
     231                                expr = chip->computes[i].from_proc; 
     232                                final_expr = 1; 
     233                        } else if (alt_feature && !strcasecmp(alt_feature->name, 
     234                                               chip->computes[i].name)) { 
     235                                expr = chip->computes[i].from_proc; 
     236                        } 
     237                } 
     238        if (sensors_read_proc(name, feature, &val)) 
     239                return -SENSORS_ERR_PROC; 
     240        if (!expr) 
     241                *result = val; 
     242        else if ((res = sensors_eval_expr(name, expr, val, result))) 
     243                return res; 
     244        return 0; 
     245} 
     246 
    235247/* Set the value of a feature of a certain chip. Note that chip should not 
    236248   contain wildcard values! This function will return 0 on success, and <0 
    …… 
    238250int sensors_set_feature(sensors_chip_name name, int feature, double value) 
    239251{ 
    240   const sensors_chip_feature *main_feature; 
    241   const sensors_chip_feature *alt_feature; 
    242   const sensors_chip *chip; 
    243   const sensors_expr *expr = NULL; 
    244   int i,res; 
    245   int final_expr=0; 
    246   double to_write; 
    247  
    248   if (sensors_chip_name_has_wildcards(name)) 
    249     return -SENSORS_ERR_WILDCARDS; 
    250   if (! (main_feature = sensors_lookup_feature_nr(name.prefix,feature))) 
    251     return -SENSORS_ERR_NO_ENTRY; 
    252   if (main_feature->compute_mapping == SENSORS_NO_MAPPING) 
    253     alt_feature = NULL; 
    254   else if (! (alt_feature = 
    255                    sensors_lookup_feature_nr(name.prefix, 
    256                                              main_feature->compute_mapping))) 
    257     return -SENSORS_ERR_NO_ENTRY; 
    258   if (! (main_feature->mode & SENSORS_MODE_W)) 
    259     return -SENSORS_ERR_ACCESS_W; 
    260   for (chip = NULL; !expr && (chip = sensors_for_all_config_chips(name,chip));) 
    261     for (i = 0; !final_expr && (i < chip->computes_count); i++) 
    262       if (!strcasecmp(main_feature->name,chip->computes[i].name)) { 
    263         expr = chip->computes->to_proc; 
    264         final_expr = 1; 
    265       } else if (alt_feature &&  
    266                  !strcasecmp(alt_feature->name,chip->computes[i].name)) 
    267         expr = chip->computes[i].to_proc; 
    268  
    269   to_write = value; 
    270   if (expr) 
    271     if ((res = sensors_eval_expr(name,expr,value,&to_write))) 
    272       return res; 
    273   if (sensors_write_proc(name,feature,to_write)) 
    274     return -SENSORS_ERR_PROC; 
    275   return 0; 
    276 } 
    277  
    278 const sensors_chip_name *sensors_get_detected_chips (int *nr) 
    279 { 
    280   const sensors_chip_name *res; 
    281   res =  *nr >= sensors_proc_chips_count?NULL:&sensors_proc_chips[*nr].name; 
    282   (*nr)++; 
    283   return res; 
     252        const sensors_chip_feature *main_feature; 
     253        const sensors_chip_feature *alt_feature; 
     254        const sensors_chip *chip; 
     255        const sensors_expr *expr = NULL; 
     256        int i, res; 
     257        int final_expr = 0; 
     258        double to_write; 
     259 
     260        if (sensors_chip_name_has_wildcards(name)) 
     261                return -SENSORS_ERR_WILDCARDS; 
     262        if (!(main_feature = sensors_lookup_feature_nr(name.prefix, feature))) 
     263                return -SENSORS_ERR_NO_ENTRY; 
     264        if (main_feature->compute_mapping == SENSORS_NO_MAPPING) 
     265                alt_feature = NULL; 
     266        else if (!(alt_feature = sensors_lookup_feature_nr(name.prefix, 
     267                                             main_feature->compute_mapping))) 
     268                return -SENSORS_ERR_NO_ENTRY; 
     269        if (!(main_feature->mode & SENSORS_MODE_W)) 
     270                return -SENSORS_ERR_ACCESS_W; 
     271        for (chip = NULL; 
     272             !expr && (chip = sensors_for_all_config_chips(name, chip));) 
     273                for (i = 0; !final_expr && (i < chip->computes_count); i++) 
     274                        if (!strcasecmp(main_feature->name, chip->computes[i].name)) { 
     275                                expr = chip->computes->to_proc; 
     276                                final_expr = 1; 
     277                        } else if (alt_feature && !strcasecmp(alt_feature->name, 
     278                                               chip->computes[i].name)) { 
     279                                expr = chip->computes[i].to_proc; 
     280                        } 
     281 
     282        to_write = value; 
     283        if (expr) 
     284                if ((res = sensors_eval_expr(name, expr, value, &to_write))) 
     285                        return res; 
     286        if (sensors_write_proc(name, feature, to_write)) 
     287                return -SENSORS_ERR_PROC; 
     288        return 0; 
     289} 
     290 
     291const sensors_chip_name *sensors_get_detected_chips(int *nr) 
     292{ 
     293        const sensors_chip_name *res; 
     294        res = (*nr >= sensors_proc_chips_count ? 
     295                        NULL : &sensors_proc_chips[*nr].name); 
     296        (*nr)++; 
     297        return res; 
    284298} 
    285299 
    286300const char *sensors_get_adapter_name(int bus_nr) 
    287301{ 
    288   int i; 
    289  
    290   if (bus_nr == SENSORS_CHIP_NAME_BUS_ISA) 
    291     return "ISA adapter"; 
    292   if (bus_nr == SENSORS_CHIP_NAME_BUS_DUMMY) 
    293     return "Dummy adapter"; 
    294   for (i=0; i < sensors_proc_bus_count; i++) 
    295     if (sensors_proc_bus[i].number == bus_nr) 
    296       return sensors_proc_bus[i].adapter; 
    297   return NULL; 
     302       int i; 
     303 
     304       if (bus_nr == SENSORS_CHIP_NAME_BUS_ISA) 
     305               return "ISA adapter"; 
     306       if (bus_nr == SENSORS_CHIP_NAME_BUS_DUMMY) 
     307               return "Dummy adapter"; 
     308       for (i = 0; i < sensors_proc_bus_count; i++) 
     309               if (sensors_proc_bus[i].number == bus_nr) 
     310                       return sensors_proc_bus[i].adapter; 
     311       return NULL; 
    298312} 
    299313 
    300314const char *sensors_get_algorithm_name(int bus_nr) 
    301315{ 
    302   int i; 
    303  
    304   if (bus_nr == SENSORS_CHIP_NAME_BUS_ISA) 
    305     return "ISA algorithm"; 
    306   if (bus_nr == SENSORS_CHIP_NAME_BUS_DUMMY) 
    307     return "Dummy algorithm"; 
    308   for (i=0; i < sensors_proc_bus_count; i++) 
    309     if (sensors_proc_bus[i].number == bus_nr) 
    310       return sensors_proc_bus[i].algorithm; 
    311   return NULL; 
     316       int i; 
     317 
     318       if (bus_nr == SENSORS_CHIP_NAME_BUS_ISA) 
     319               return "ISA algorithm"; 
     320       if (bus_nr == SENSORS_CHIP_NAME_BUS_DUMMY) 
     321               return "Dummy algorithm"; 
     322       for (i = 0; i < sensors_proc_bus_count; i++) 
     323               if (sensors_proc_bus[i].number == bus_nr) 
     324                       return sensors_proc_bus[i].algorithm; 
     325       return NULL; 
    312326} 
    313327 
    314328/* nr1-1 is the last main feature found; nr2-1 is the last subfeature found */ 
    315 const sensors_feature_data *sensors_get_all_features (sensors_chip_name name,  
    316                                                       int *nr1, int*nr2) 
    317 { 
    318   sensors_chip_feature *feature_list; 
    319   int i; 
    320  
    321   for (i = 0; sensors_chip_features_list[i].prefix; i++) 
    322     if (!strcasecmp(sensors_chip_features_list[i].prefix,name.prefix)) { 
    323       feature_list=sensors_chip_features_list[i].feature; 
    324       if (!*nr1 && !*nr2) { /* Return the first entry */ 
    325         if (!feature_list[0].name) /* The list may be empty */ 
    326           return NULL; 
    327         *nr1 = *nr2 = 1; 
    328         return (sensors_feature_data *) (feature_list + 0); 
    329       } 
    330       for ((*nr2)++; feature_list[*nr2-1].name; (*nr2)++)  
    331         if (feature_list[*nr2-1].logical_mapping == feature_list[*nr1-1].number) 
    332           return (sensors_feature_data *) (feature_list + *nr2 - 1); 
    333       for ((*nr1)++; feature_list[*nr1-1].name &&  
    334                   (feature_list[*nr1-1].logical_mapping != SENSORS_NO_MAPPING); 
    335            (*nr1)++); 
    336       *nr2 = *nr1; 
    337       if (! feature_list[*nr1-1].name) 
    338         return NULL; 
    339       return (sensors_feature_data *) (feature_list + *nr1 - 1); 
    340     } 
    341   return NULL; 
    342 } 
    343  
    344 int sensors_eval_expr(sensors_chip_name chipname, const sensors_expr *expr, 
    345                       double val, double *result) 
    346 { 
    347   double res1,res2; 
    348   int res; 
    349   const sensors_chip_feature *feature; 
    350  
    351   if (expr->kind == sensors_kind_val) { 
    352     *result = expr->data.val; 
    353     return 0; 
    354   } 
    355   if (expr->kind == sensors_kind_source) { 
    356     *result = val; 
    357     return 0; 
    358   } 
    359   if (expr->kind == sensors_kind_var) { 
    360     if (! (feature = sensors_lookup_feature_name(chipname.prefix, 
    361                                                 expr->data.var))) 
    362       return SENSORS_ERR_NO_ENTRY; 
    363     if (! (res = sensors_get_feature(chipname,feature->number,result))) 
    364       return res; 
    365     return 0; 
    366   } 
    367   if ((res = sensors_eval_expr(chipname,expr->data.subexpr.sub1,val,&res1))) 
    368     return res; 
    369   if (expr->data.subexpr.sub2 && 
    370       (res = sensors_eval_expr(chipname,expr->data.subexpr.sub2,val,&res2))) 
    371     return res; 
    372   switch(expr->data.subexpr.op) { 
    373   case sensors_add: 
    374     *result = res1 + res2; 
    375     return 0; 
    376   case sensors_sub: 
    377     *result = res1 - res2; 
    378     return 0; 
    379   case sensors_multiply: 
    380     *result = res1 * res2; 
    381     return 0; 
    382   case sensors_divide: 
    383     if (res2 == 0.0) 
    384       return -SENSORS_ERR_DIV_ZERO; 
    385     *result = res1 / res2; 
    386     return 0; 
    387   case sensors_negate: 
    388     *result = -res1; 
    389     return 0; 
    390   case sensors_exp: 
    391     *result = exp(res1); 
    392     return 0; 
    393   case sensors_log: 
    394     if (res1 < 0.0) 
    395       return -SENSORS_ERR_DIV_ZERO; 
    396     *result = log(res1); 
    397     return 0; 
    398   } 
    399   return 0; 
     329const sensors_feature_data *sensors_get_all_features(sensors_chip_name name, 
     330                                                     int *nr1, int *nr2) 
     331{ 
     332        sensors_chip_feature *feature_list; 
     333        int i; 
     334 
     335        for (i = 0; sensors_chip_features_list[i].prefix; i++) 
     336                if (!strcasecmp(sensors_chip_features_list[i].prefix, name.prefix)) { 
     337                        feature_list = sensors_chip_features_list[i].feature; 
     338                        if (!*nr1 && !*nr2) {   /* Return the first entry */ 
     339                                if (!feature_list[0].name)      /* The list may be empty */ 
     340                                        return NULL; 
     341                                *nr1 = *nr2 = 1; 
     342                                return (sensors_feature_data *)feature_list; 
     343                        } 
     344                        for ((*nr2)++; feature_list[*nr2 - 1].name; (*nr2)++) 
     345                                if (feature_list[*nr2 - 1].logical_mapping == 
     346                                    feature_list[*nr1 - 1].number) 
     347                                        return (sensors_feature_data *) 
     348                                                (feature_list + *nr2 - 1); 
     349                        for ((*nr1)++; 
     350                             feature_list[*nr1 - 1].name 
     351                             && (feature_list[*nr1 - 1].logical_mapping != 
     352                                 SENSORS_NO_MAPPING); (*nr1)++) ; 
     353                        *nr2 = *nr1; 
     354                        if (!feature_list[*nr1 - 1].name) 
     355                                return NULL; 
     356                        return (sensors_feature_data *)(feature_list + *nr1 - 1); 
     357                } 
     358        return NULL; 
     359} 
     360 
     361int sensors_eval_expr(sensors_chip_name chipname, const sensors_expr * expr, 
     362                      double val, double *result) 
     363{ 
     364        double res1, res2; 
     365        int res; 
     366        const sensors_chip_feature *feature; 
     367 
     368        if (expr->kind == sensors_kind_val) { 
     369                *result = expr->data.val; 
     370                return 0; 
     371        } 
     372        if (expr->kind == sensors_kind_source) { 
     373                *result = val; 
     374                return 0; 
     375        } 
     376        if (expr->kind == sensors_kind_var) { 
     377                if (!(feature = sensors_lookup_feature_name(chipname.prefix, 
     378                                                            expr->data.var))) 
     379                        return SENSORS_ERR_NO_ENTRY; 
     380                if (!(res = sensors_get_feature(chipname, feature->number, result))) 
     381                        return res; 
     382                return 0; 
     383        } 
     384        if ((res = sensors_eval_expr(chipname, expr->data.subexpr.sub1, val, &res1))) 
     385                return res; 
     386        if (expr->data.subexpr.sub2 && 
     387            (res = sensors_eval_expr(chipname, expr->data.subexpr.sub2, val, &res2))) 
     388                return res; 
     389        switch (expr->data.subexpr.op) { 
     390        case sensors_add: 
     391                *result = res1 + res2; 
     392                return 0; 
     393        case sensors_sub: 
     394                *result = res1 - res2; 
     395                return 0; 
     396        case sensors_multiply: 
     397                *result = res1 * res2; 
     398                return 0; 
     399        case sensors_divide: 
     400                if (res2 == 0.0) 
     401                        return -SENSORS_ERR_DIV_ZERO; 
     402                *result = res1 / res2; 
     403                return 0; 
     404        case sensors_negate: 
     405                *result = -res1; 
     406                return 0; 
     407        case sensors_exp: 
     408                *result = exp(res1); 
     409                return 0; 
     410        case sensors_log: 
     411                if (res1 < 0.0) 
     412                        return -SENSORS_ERR_DIV_ZERO; 
     413                *result = log(res1); 
     414                return 0; 
     415        } 
     416        return 0; 
    400417} 
    401418 
    …… 
    405422int sensors_do_this_chip_sets(sensors_chip_name name) 
    406423{ 
    407   sensors_chip *chip; 
    408   double value; 
    409   int i, j; 
    410   int err = 0, res; 
    411   const sensors_chip_feature *feature; 
    412   int *feature_list = NULL; 
    413   int feature_count = 0; 
    414   int feature_max = 0; 
    415   int feature_nr; 
    416  
    417   for(chip = NULL; (chip = sensors_for_all_config_chips(name,chip));) 
    418     for(i = 0; i < chip->sets_count; i++) { 
    419       feature = sensors_lookup_feature_name(name.prefix,chip->sets[i].name); 
    420       if (! feature) { 
    421         sensors_parse_error("Unknown feature name",chip->sets[i].lineno); 
    422         err = SENSORS_ERR_NO_ENTRY; 
    423         continue; 
    424       } 
    425       feature_nr = feature->number; 
    426  
    427       /* Check whether we already set this feature */ 
    428       for(j = 0; j < feature_count; j++) 
    429         if(feature_list[j] == feature_nr) 
    430           break; 
    431       if (j != feature_count) 
    432         continue; 
    433       sensors_add_array_el(&feature_nr,&feature_list,&feature_count, 
    434                         &feature_max, sizeof(int)); 
    435  
    436       res = sensors_eval_expr(name,chip->sets[i].value,0,&value); 
    437       if (res) { 
    438         sensors_parse_error("Parsing expression",chip->sets[i].lineno); 
    439         err = res; 
    440         continue; 
    441       } 
    442       if ((res = sensors_set_feature(name,feature_nr,value))) { 
    443         err = res; 
    444         continue; 
    445       } 
    446     } 
    447   free(feature_list); 
    448   return err; 
     424        sensors_chip *chip; 
     425        double value; 
     426        int i, j; 
     427        int err = 0, res; 
     428        const sensors_chip_feature *feature; 
     429        int *feature_list = NULL; 
     430        int feature_count = 0; 
     431        int feature_max = 0; 
     432        int feature_nr; 
     433 
     434        for (chip = NULL; (chip = sensors_for_all_config_chips(name, chip));) 
     435                for (i = 0; i < chip->sets_count; i++) { 
     436                        feature = sensors_lookup_feature_name(name.prefix, 
     437                                                        chip->sets[i].name); 
     438                        if (!feature) { 
     439                                sensors_parse_error("Unknown feature name", 
     440                                                    chip->sets[i].lineno); 
     441                                err = SENSORS_ERR_NO_ENTRY; 
     442                                continue; 
     443                        } 
     444                        feature_nr = feature->number; 
     445 
     446                        /* Check whether we already set this feature */ 
     447                        for (j = 0; j < feature_count; j++) 
     448                                if (feature_list[j] == feature_nr) 
     449                                        break; 
     450                        if (j != feature_count) 
     451                                continue; 
     452                        sensors_add_array_el(&feature_nr, &feature_list, 
     453                                             &feature_count, &feature_max, 
     454                                             sizeof(int)); 
     455 
     456                        res = sensors_eval_expr(name, chip->sets[i].value, 0, 
     457                                              &value); 
     458                        if (res) { 
     459                                sensors_parse_error("Parsing expression", 
     460                                                    chip->sets[i].lineno); 
     461                                err = res; 
     462                                continue; 
     463                        } 
     464                        if ((res = sensors_set_feature(name, feature_nr, value))) { 
     465                                err = res; 
     466                                continue; 
     467                        } 
     468                } 
     469        free(feature_list); 
     470        return err; 
    449471} 
    450472 
    …… 
    453475int sensors_do_chip_sets(sensors_chip_name name) 
    454476{ 
    455   int nr,this_res; 
    456   const sensors_chip_name *found_name; 
    457   int res = 0; 
    458  
    459   for (nr = 0; (found_name = sensors_get_detected_chips(&nr));) 
    460     if (sensors_match_chip(name,*found_name)) { 
    461       this_res = sensors_do_this_chip_sets(*found_name); 
    462       if (! res) 
    463         res = this_res; 
    464     } 
    465   return res; 
     477       int nr, this_res; 
     478       const sensors_chip_name *found_name; 
     479       int res = 0; 
     480 
     481       for (nr = 0; (found_name = sensors_get_detected_chips(&nr));) 
     482               if (sensors_match_chip(name, *found_name)) { 
     483                       this_res = sensors_do_this_chip_sets(*found_name); 
     484                       if (!res) 
     485                               res = this_res; 
     486               } 
     487       return res; 
    466488} 
    467489 
    …… 
    470492int sensors_do_all_sets(void) 
    471493{ 
    472   sensors_chip_name name = { SENSORS_CHIP_NAME_PREFIX_ANY,  
    473                              SENSORS_CHIP_NAME_BUS_ANY, 
    474                              SENSORS_CHIP_NAME_ADDR_ANY }; 
    475   return sensors_do_chip_sets(name); 
    476 } 
    477  
     494        sensors_chip_name name = { SENSORS_CHIP_NAME_PREFIX_ANY, 
     495               SENSORS_CHIP_NAME_BUS_ANY, 
     496                SENSORS_CHIP_NAME_ADDR_ANY 
     497       }; 
     498        return sensors_do_chip_sets(name); 
     499}