Changeset 9300


Ignore:
Timestamp:
2007-10-14T04:15:37+02:00 (10 years ago)
Author:
blogic
Message:

add possibility to set default .config values

Location:
trunk
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Config.in

    r9191 r9300  
    145145 
    146146source "toolchain/Config.in" 
     147menuconfig BUILDSYSTEM_SETTINGS 
     148    bool "Buildsystem settings"  
     149 
     150config DOWNLOAD_FOLDER 
     151        string 
     152        prompt "Download folder" 
     153        default "" 
     154        depends BUILDSYSTEM_SETTINGS  
    147155source "target/imagebuilder/Config.in" 
    148156source "target/sdk/Config.in" 
     
    150158source "tmp/.config-package.in" 
    151159 
     160 
  • trunk/include/toplevel.mk

    r9215 r9300  
    5252scripts/config/mconf: 
    5353        @+$(MAKE) -C scripts/config all 
     54 
     55$(call  rdep,scripts/config,scripts/config/mconf) 
    5456 
    5557scripts/config/conf: 
  • trunk/rules.mk

    r9167 r9300  
    3333OPTIMIZE_FOR_CPU:=$(ARCH) 
    3434 
    35 DL_DIR:=$(TOPDIR)/dl 
     35DL_DIR:=$(call qstrip,$(if $(CONFIG_DOWNLOAD_FOLDER), $(CONFIG_DOWNLOAD_FOLDER),$(TOPDIR)/dl)) 
    3636BIN_DIR:=$(TOPDIR)/bin 
    3737INCLUDE_DIR:=$(TOPDIR)/include 
  • trunk/scripts/config/Makefile

    r6502 r9300  
    2828 
    2929conf: $(conf-objs) 
    30 mconf: $(mconf-objs) 
     30mconf: $(mconf-objs)  
    3131 
    3232clean: 
     
    3434        $(MAKE) -C lxdialog clean 
    3535 
    36 zconf.tab.o: lex.zconf.c zconf.hash.c 
     36zconf.tab.o: lex.zconf.c zconf.hash.c confdata.c 
    3737 
    3838kconfig_load.o: lkc_defs.h 
  • trunk/scripts/config/confdata.c

    r6502 r9300  
    1414#define LKC_DIRECT_LINK 
    1515#include "lkc.h" 
     16 
     17#define LOCAL_BUILD_SETTINGS "/.openwrt/defconfig" 
    1618 
    1719static void conf_warning(const char *fmt, ...) 
     
    8890        struct symbol *sym; 
    8991        int i; 
     92 
     93        for_all_symbols(i, sym) { 
     94                sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED; 
     95                if (sym_is_choice(sym)) 
     96                        sym->flags &= ~SYMBOL_NEW; 
     97                sym->flags &= ~SYMBOL_VALID; 
     98                switch (sym->type) { 
     99                case S_INT: 
     100                case S_HEX: 
     101                case S_STRING: 
     102                        if (sym->user.val) 
     103                                free(sym->user.val); 
     104                default: 
     105                        sym->user.val = NULL; 
     106                        sym->user.tri = no; 
     107                } 
     108        } 
     109        conf_read_simple(NULL, 0); 
     110} 
     111 
     112int conf_read_file(FILE *in, struct symbol *sym){ 
     113        char line[1024]; 
     114        char *p, *p2; 
     115 
     116        while (fgets(line, sizeof(line), in)) { 
     117                conf_lineno++; 
     118                sym = NULL; 
     119                switch (line[0]) { 
     120                case '#': 
     121                        if (memcmp(line + 2, "CONFIG_", 7)) 
     122                                continue; 
     123                        p = strchr(line + 9, ' '); 
     124                        if (!p) 
     125                                continue; 
     126                        *p++ = 0; 
     127                        if (strncmp(p, "is not set", 10)) 
     128                                continue; 
     129                        sym = sym_find(line + 9); 
     130                        if (!sym) { 
     131                                //conf_warning("trying to assign nonexistent symbol %s", line + 9); 
     132                                break; 
     133                        } /*else if (!(sym->flags & SYMBOL_NEW)) { 
     134                                //conf_warning("trying to reassign symbol %s", sym->name); 
     135                                break; 
     136                        }*/ 
     137                        switch (sym->type) { 
     138                        case S_BOOLEAN: 
     139                        case S_TRISTATE: 
     140                                sym->user.tri = no; 
     141                                sym->flags &= ~SYMBOL_NEW; 
     142                                break; 
     143                        default: 
     144                                ; 
     145                        } 
     146                        break; 
     147                case 'C': 
     148                        if (memcmp(line, "CONFIG_", 7)) { 
     149                                conf_warning("unexpected data"); 
     150                                continue; 
     151                        } 
     152                        p = strchr(line + 7, '='); 
     153                        if (!p) 
     154                                continue; 
     155                        *p++ = 0; 
     156                        p2 = strchr(p, '\n'); 
     157                        if (p2) 
     158                                *p2 = 0; 
     159                        sym = sym_find(line + 7); 
     160                        if (!sym) { 
     161                                //conf_warning("trying to assign nonexistent symbol %s", line + 7); 
     162                                break; 
     163                        } /*else if (!(sym->flags & SYMBOL_NEW)) { 
     164                                conf_warning("trying to reassign symbol %s", sym->name); 
     165                                break; 
     166                        }*/ 
     167                        switch (sym->type) { 
     168                        case S_TRISTATE: 
     169                                if (p[0] == 'm') { 
     170                                        sym->user.tri = mod; 
     171                                        sym->flags &= ~SYMBOL_NEW; 
     172                                        break; 
     173                                } 
     174                        case S_BOOLEAN: 
     175                                if (p[0] == 'y') { 
     176                                        sym->user.tri = yes; 
     177                                        sym->flags &= ~SYMBOL_NEW; 
     178                                        break; 
     179                                } 
     180                                if (p[0] == 'n') { 
     181                                        sym->user.tri = no; 
     182                                        sym->flags &= ~SYMBOL_NEW; 
     183                                        break; 
     184                                } 
     185                                conf_warning("symbol value '%s' invalid for %s", p, sym->name); 
     186                                break; 
     187                        case S_STRING: 
     188                                if (*p++ != '"') 
     189                                        break; 
     190                                for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) { 
     191                                        if (*p2 == '"') { 
     192                                                *p2 = 0; 
     193                                                break; 
     194                                        } 
     195                                        memmove(p2, p2 + 1, strlen(p2)); 
     196                                } 
     197                                if (!p2) { 
     198                                        conf_warning("invalid string found"); 
     199                                        continue; 
     200                                } 
     201                        case S_INT: 
     202                        case S_HEX: 
     203                                if (sym_string_valid(sym, p)) { 
     204                                        sym->user.val = strdup(p); 
     205                                        sym->flags &= ~SYMBOL_NEW; 
     206                                } else { 
     207                                        conf_warning("symbol value '%s' invalid for %s", p, sym->name); 
     208                                        continue; 
     209                                } 
     210                                break; 
     211                        default: 
     212                                ; 
     213                        } 
     214                        break; 
     215                case '\n': 
     216                        break; 
     217                default: 
     218                        conf_warning("unexpected data"); 
     219                        continue; 
     220                } 
     221                if (sym && sym_is_choice_value(sym)) { 
     222                        struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); 
     223                        switch (sym->user.tri) { 
     224                        case no: 
     225                                break; 
     226                        case mod: 
     227                                if (cs->user.tri == yes) { 
     228                                        conf_warning("%s creates inconsistent choice state", sym->name); 
     229                                        cs->flags |= SYMBOL_NEW; 
     230                                } 
     231                                break; 
     232                        case yes: 
     233                                if (cs->user.tri != no) { 
     234                                        conf_warning("%s creates inconsistent choice state", sym->name); 
     235                                        cs->flags |= SYMBOL_NEW; 
     236                                } else 
     237                                        cs->user.val = sym; 
     238                                break; 
     239                        } 
     240                        cs->user.tri = E_OR(cs->user.tri, sym->user.tri); 
     241                } 
     242        } 
     243        fclose(in); 
     244 
     245        return 0; 
     246} 
     247 
     248int conf_read_simple(const char *name, int load_config) 
     249{ 
     250        FILE *in = NULL; 
     251        FILE *defaults = NULL; 
     252        struct symbol *sym; 
     253        int i; 
     254        char *home_dir = getenv("HOME"); 
     255        char *default_config_path = NULL; 
     256         
     257        if(home_dir){ 
     258                        default_config_path = malloc(strlen(home_dir) + sizeof(LOCAL_BUILD_SETTINGS) + 1); 
     259                        sprintf(default_config_path, "%s%s", home_dir, LOCAL_BUILD_SETTINGS); 
     260                        defaults = zconf_fopen(default_config_path); 
     261                        if(defaults) 
     262                                        printf("# using buildsystem predefines from %s\n", default_config_path); 
     263                        free(default_config_path); 
     264        } 
     265         
     266        if(load_config){ 
     267                if (name) { 
     268                        in = zconf_fopen(name); 
     269                } else { 
     270                        const char **names = conf_confnames; 
     271                        while ((name = *names++)) { 
     272                                name = conf_expand_value(name); 
     273                                in = zconf_fopen(name); 
     274                                if (in) { 
     275                                        printf(_("#\n" 
     276                                                 "# using defaults found in %s\n" 
     277                                                 "#\n"), name); 
     278                                        break; 
     279                                } 
     280                        } 
     281                } 
     282        } 
     283 
     284        if (!in && !defaults) 
     285                return 1; 
     286 
     287        conf_filename = name; 
     288        conf_lineno = 0; 
     289        conf_warnings = 0; 
     290        conf_unsaved = 0; 
    90291         
    91292        for_all_symbols(i, sym) { 
     
    105306                } 
    106307        } 
    107 } 
    108  
    109 int conf_read_simple(const char *name) 
    110 { 
    111         FILE *in = NULL; 
    112         char line[1024]; 
    113         char *p, *p2; 
    114         struct symbol *sym; 
    115         int i; 
    116  
    117         if (name) { 
    118                 in = zconf_fopen(name); 
    119         } else { 
    120                 const char **names = conf_confnames; 
    121                 while ((name = *names++)) { 
    122                         name = conf_expand_value(name); 
    123                         in = zconf_fopen(name); 
    124                         if (in) { 
    125                                 printf(_("#\n" 
    126                                          "# using defaults found in %s\n" 
    127                                          "#\n"), name); 
    128                                 break; 
    129                         } 
    130                 } 
    131         } 
    132         if (!in) 
    133                 return 1; 
    134  
    135         conf_filename = name; 
    136         conf_lineno = 0; 
    137         conf_warnings = 0; 
    138         conf_unsaved = 0; 
    139  
    140         for_all_symbols(i, sym) { 
    141                 sym->flags |= SYMBOL_NEW | SYMBOL_CHANGED; 
    142                 if (sym_is_choice(sym)) 
    143                         sym->flags &= ~SYMBOL_NEW; 
    144                 sym->flags &= ~SYMBOL_VALID; 
    145                 switch (sym->type) { 
    146                 case S_INT: 
    147                 case S_HEX: 
    148                 case S_STRING: 
    149                         if (sym->user.val) 
    150                                 free(sym->user.val); 
    151                 default: 
    152                         sym->user.val = NULL; 
    153                         sym->user.tri = no; 
    154                 } 
    155         } 
    156  
    157         while (fgets(line, sizeof(line), in)) { 
    158                 conf_lineno++; 
    159                 sym = NULL; 
    160                 switch (line[0]) { 
    161                 case '#': 
    162                         if (memcmp(line + 2, "CONFIG_", 7)) 
    163                                 continue; 
    164                         p = strchr(line + 9, ' '); 
    165                         if (!p) 
    166                                 continue; 
    167                         *p++ = 0; 
    168                         if (strncmp(p, "is not set", 10)) 
    169                                 continue; 
    170                         sym = sym_find(line + 9); 
    171                         if (!sym) { 
    172                                 conf_warning("trying to assign nonexistent symbol %s", line + 9); 
    173                                 break; 
    174                         } else if (!(sym->flags & SYMBOL_NEW)) { 
    175                                 conf_warning("trying to reassign symbol %s", sym->name); 
    176                                 break; 
    177                         } 
    178                         switch (sym->type) { 
    179                         case S_BOOLEAN: 
    180                         case S_TRISTATE: 
    181                                 sym->user.tri = no; 
    182                                 sym->flags &= ~SYMBOL_NEW; 
    183                                 break; 
    184                         default: 
    185                                 ; 
    186                         } 
    187                         break; 
    188                 case 'C': 
    189                         if (memcmp(line, "CONFIG_", 7)) { 
    190                                 conf_warning("unexpected data"); 
    191                                 continue; 
    192                         } 
    193                         p = strchr(line + 7, '='); 
    194                         if (!p) 
    195                                 continue; 
    196                         *p++ = 0; 
    197                         p2 = strchr(p, '\n'); 
    198                         if (p2) 
    199                                 *p2 = 0; 
    200                         sym = sym_find(line + 7); 
    201                         if (!sym) { 
    202                                 conf_warning("trying to assign nonexistent symbol %s", line + 7); 
    203                                 break; 
    204                         } else if (!(sym->flags & SYMBOL_NEW)) { 
    205                                 conf_warning("trying to reassign symbol %s", sym->name); 
    206                                 break; 
    207                         } 
    208                         switch (sym->type) { 
    209                         case S_TRISTATE: 
    210                                 if (p[0] == 'm') { 
    211                                         sym->user.tri = mod; 
    212                                         sym->flags &= ~SYMBOL_NEW; 
    213                                         break; 
    214                                 } 
    215                         case S_BOOLEAN: 
    216                                 if (p[0] == 'y') { 
    217                                         sym->user.tri = yes; 
    218                                         sym->flags &= ~SYMBOL_NEW; 
    219                                         break; 
    220                                 } 
    221                                 if (p[0] == 'n') { 
    222                                         sym->user.tri = no; 
    223                                         sym->flags &= ~SYMBOL_NEW; 
    224                                         break; 
    225                                 } 
    226                                 conf_warning("symbol value '%s' invalid for %s", p, sym->name); 
    227                                 break; 
    228                         case S_STRING: 
    229                                 if (*p++ != '"') 
    230                                         break; 
    231                                 for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) { 
    232                                         if (*p2 == '"') { 
    233                                                 *p2 = 0; 
    234                                                 break; 
    235                                         } 
    236                                         memmove(p2, p2 + 1, strlen(p2)); 
    237                                 } 
    238                                 if (!p2) { 
    239                                         conf_warning("invalid string found"); 
    240                                         continue; 
    241                                 } 
    242                         case S_INT: 
    243                         case S_HEX: 
    244                                 if (sym_string_valid(sym, p)) { 
    245                                         sym->user.val = strdup(p); 
    246                                         sym->flags &= ~SYMBOL_NEW; 
    247                                 } else { 
    248                                         conf_warning("symbol value '%s' invalid for %s", p, sym->name); 
    249                                         continue; 
    250                                 } 
    251                                 break; 
    252                         default: 
    253                                 ; 
    254                         } 
    255                         break; 
    256                 case '\n': 
    257                         break; 
    258                 default: 
    259                         conf_warning("unexpected data"); 
    260                         continue; 
    261                 } 
    262                 if (sym && sym_is_choice_value(sym)) { 
    263                         struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym)); 
    264                         switch (sym->user.tri) { 
    265                         case no: 
    266                                 break; 
    267                         case mod: 
    268                                 if (cs->user.tri == yes) { 
    269                                         conf_warning("%s creates inconsistent choice state", sym->name); 
    270                                         cs->flags |= SYMBOL_NEW; 
    271                                 } 
    272                                 break; 
    273                         case yes: 
    274                                 if (cs->user.tri != no) { 
    275                                         conf_warning("%s creates inconsistent choice state", sym->name); 
    276                                         cs->flags |= SYMBOL_NEW; 
    277                                 } else 
    278                                         cs->user.val = sym; 
    279                                 break; 
    280                         } 
    281                         cs->user.tri = E_OR(cs->user.tri, sym->user.tri); 
    282                 } 
    283         } 
    284         fclose(in); 
    285  
     308 
     309        if(defaults) 
     310                conf_read_file(defaults, sym); 
     311         
     312        if(in) 
     313                conf_read_file(in, sym); 
     314         
    286315        if (modules_sym) 
    287316                sym_calc_value(modules_sym); 
    288         return 0; 
     317 
     318        return 0;        
    289319} 
    290320 
     
    296326        int i; 
    297327 
    298         if (conf_read_simple(name)) 
     328        if (conf_read_simple(name, 1)) 
    299329                return 1; 
    300330 
  • trunk/scripts/config/lkc_proto.h

    r6502 r9300  
    44P(conf_read,int,(const char *name)); 
    55P(conf_reset,void,(void)); 
    6 P(conf_read_simple,int,(const char *name)); 
     6P(conf_read_simple,int,(const char *name, int load_config)); 
    77P(conf_write,int,(const char *name)); 
    88 
Note: See TracChangeset for help on using the changeset viewer.