Changeset 4737

Show
Ignore:
Timestamp:
08/31/07 17:09:26 (6 years ago)
Author:
khali
Message:

Reorder functions so that forward declarations are no longer needed.

Files:
1 modified

Legend:

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

    r4736 r4737  
    2828#include "scanner.h" 
    2929 
    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  
    4030int sensors_init(FILE *input) 
    4131{ 
     
    5444                return res; 
    5545        return 0; 
     46} 
     47 
     48static void free_chip_name(sensors_chip_name *name) 
     49{ 
     50        free(name->prefix); 
     51        free(name->path); 
     52} 
     53 
     54static 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 
     63static void free_bus(sensors_bus *bus) 
     64{ 
     65        free(bus->adapter); 
     66} 
     67 
     68static void free_label(sensors_label *label) 
     69{ 
     70        free(label->name); 
     71        free(label->value); 
     72} 
     73 
     74static 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 
     87static void free_set(sensors_set *set) 
     88{ 
     89        free(set->name); 
     90        free_expr(set->value); 
     91} 
     92 
     93static 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 
     100static void free_ignore(sensors_ignore *ignore) 
     101{ 
     102        free(ignore->name); 
     103} 
     104 
     105static 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; 
    56133} 
    57134 
     
    88165        sensors_proc_bus_count = sensors_proc_bus_max = 0; 
    89166} 
    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 }