WebSVN – HelenOS-historic – Diff – /kernel/trunk/tools/config.py


#!/usr/bin/env python
"""
Kernel configuration script
"""
import sys
import os
import re
 
INPUT = 'kernel.config'
OUTPUT = 'Makefile.config'
TMPOUTPUT = 'Makefile.config.tmp'
 
class DefaultDialog:
    "Wrapper dialog that tries to return default values"
    def __init__(self, dlg):
        self.dlg = dlg
 
    def set_title(self,text):
        self.dlg.set_title(text)
       
    def yesno(self, text, default=None):
        if default is not None:
            return default
        return self.dlg.yesno(text, default)
    def noyes(self, text, default=None):
        if default is not None:
            return default
        return self.dlg.noyes(text, default)
   
    def choice(self, text, choices, defopt=None):
        if defopt is not None:
            return choices[defopt][0]
        return self.dlg.choice(text, choices, defopt)
 
class NoDialog:
    def __init__(self):
        self.printed = None
        self.title = 'HelenOS Configuration'
 
    def print_title(self):
        if not self.printed:
            sys.stdout.write("*** %s ***\n" % self.title)
            self.printed = True
 
    def set_title(self, text):
        self.title = text
        self.printed = False
   
    def noyes(self, text, default=None):
        if not default:
            default = 'n'
        return self.yesno(text, default)
   
    def yesno(self, text, default=None):
        self.print_title()
       
        if default != 'n':
            default = 'y'
        while 1:
            sys.stdout.write("%s (y/n)[%s]: " % (text,default))
            inp = sys.stdin.readline()
            if not inp:
                raise EOFError
            inp = inp.strip().lower()
            if not inp:
                return default
            if inp == 'y':
                return 'y'
            elif inp == 'n':
                return 'n'
 
    def _print_choice(self, text, choices, defopt):
        sys.stdout.write('%s:\n' % text)
        for i,(text,descr) in enumerate(choices):
            sys.stdout.write('\t%2d. %s\n' % (i, descr))
        if defopt is not None:
            sys.stdout.write('Enter choice number[%d]: ' % defopt)
        else:
            sys.stdout.write('Enter choice number: ')
       
    def choice(self, text, choices, defopt=None):
        self.print_title()
        while 1:
            self._print_choice(text, choices, defopt)
            inp = sys.stdin.readline()
            if not inp:
                raise EOFError
            if not inp.strip():
                if defopt is not None:
                    return choices[defopt][0]
                continue
            try:
                number = int(inp.strip())
            except ValueError:
                continue
            if number < 0 or number >= len(choices):
                continue
            return choices[number][0]
 
 
class Dialog(NoDialog):
    def __init__(self):
        NoDialog.__init__(self)
        self.dlgcmd = os.environ.get('DIALOG','dialog')
        self.title = 'HelenOS Configuration'
       
        if os.system('%s --print-maxsize >/dev/null 2>&1' % self.dlgcmd) != 0:
            raise NotImplementedError
 
    def set_title(self,text):
        self.title = text
       
    def calldlg(self,*args,**kw):
        "Wrapper for calling 'dialog' program"
        indesc, outdesc = os.pipe()
        pid = os.fork()
        if not pid:
            os.close(2)
            os.dup(outdesc)
            os.close(indesc)
           
            dlgargs = [self.dlgcmd,'--title',self.title]
            for key,val in kw.items():
                dlgargs.append('--'+key)
                dlgargs.append(val)
            dlgargs += args            
            os.execlp(self.dlgcmd,*dlgargs)
 
        os.close(outdesc)
        errout = os.fdopen(indesc,'r')
        data = errout.read()
        errout.close()
           
        pid,status = os.wait()
        if not os.WIFEXITED(status):
            raise EOFError
        status = os.WEXITSTATUS(status)
        if status == 255:
            raise EOFError
        return status,data
       
    def yesno(self, text, default=None):
        text = text + ':'
        width = '50'
        height = '5'
        if len(text) < 48:
            text = ' '*int(((48-len(text))/2)) + text
        else:
            width = '0'
            height = '0'
        if default == 'n':
            res,data = self.calldlg('--defaultno','--yesno',text,height,width)
        else:
            res,data = self.calldlg('--yesno',text,height,width)
 
        if res == 0:
            return 'y'
        return 'n'
   
    def choice(self, text, choices, defopt=None):
        text = text + ':'
        width = '50'
        height = str(8 + len(choices))
        args = []
        for key,val in choices:
            args.append(key)
            args.append(val)
 
        kw = {}
        if defopt:
            kw['default-item'] = choices[defopt][0]
        res,data = self.calldlg('--nocancel','--menu',text,height,width,
                                str(len(choices)),*args, **kw)
        if res:
            print data
            raise EOFError
        return data
   
def read_defaults(fname,defaults):
    "Read saved values from last configuration run"
    f = file(fname,'r')
    for line in f:
        res = re.match(r'^(?:#!# )?([^#]\w*)\s*=\s*(.*?)\s*$', line)
        if res:
            defaults[res.group(1)] = res.group(2)
    f.close()
 
def check_condition(text, defaults):
    result = True
    conds = text.split('&')
    for cond in conds:
        if cond.startswith('(') and cond.endswith(')'):
            cond = cond[1:-1]
        if not check_dnf(cond, defaults):
            return False
    return True
 
def check_dnf(text, defaults):
    """
    Check that the condition specified on input line is True
 
    only CNF is supported
    """
    conds = text.split('|')
    for cond in conds:
        res = re.match(r'^(.*?)(!?=)(.*)$', cond)
        if not res:
            raise RuntimeError("Invalid condition: %s" % cond)
        condname = res.group(1)
        oper = res.group(2)
        condval = res.group(3)
        if not defaults.has_key(condname):
            raise RuntimeError("Condition var %s does not exist: %s" % \
                               (condname,text))
 
 
        if oper=='=' and  condval == defaults[condname]:
            return True
        if oper == '!=' and condval != defaults[condname]:
            return True
    return False
 
def parse_config(input, output, dlg, defaults={}):
    "Parse configuration file and create Makefile.config on the fly"
    f = file(input, 'r')
    outf = file(output, 'w')
 
    outf.write('#########################################\n')
    outf.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
    outf.write('#########################################\n\n')
 
    comment = ''
    default = None
    choices = []
    for line in f:
        if line.startswith('%'):
            res = re.match(r'^%\s*(?:\[(.*?)\])?\s*(.*)$', line)
            if not res:
                raise RuntimeError('Invalid command: %s' % line)
            if res.group(1):
                if not check_condition(res.group(1), defaults):
                    continue
            args = res.group(2).strip().split(' ')
            cmd = args[0].lower()
            args = args[1:]
            if cmd == 'askdefault':
                if isinstance(dlg, DefaultDialog):
                    continue
                res = dlg.noyes('Change kernel configuration')
                if res == 'n':
                    dlg = DefaultDialog(dlg)
            elif cmd == 'saveas':
                outf.write('%s = %s\n' % (args[1],defaults[args[0]]))
               
            continue
           
        if line.startswith('!'):
            # Ask a question
            res = re.search(r'!\s*(?:\[(.*?)\])?\s*([^\s]+)\s*\((.*)\)\s*$', line)
            if not res:
                raise RuntimeError("Weird line: %s" % line)
            varname = res.group(2)
            vartype = res.group(3)
 
            default = defaults.get(varname,None)
 
            if res.group(1):
                if not check_condition(res.group(1), defaults):
                    if default is not None:
                        outf.write('#!# %s = %s\n' % (varname, default))
                    # Clear cumulated values
                    comment = ''
                    default = None
                    choices = []
                    continue
 
            if vartype == 'y/n':
                result = dlg.yesno(comment, default)
            elif vartype == 'n/y':
                result = dlg.noyes(comment, default)
            elif vartype == 'choice':
                defopt = None
                if default is not None:
                    for i,(key,val) in enumerate(choices):
                        if key == default:
                            defopt = i
                            break
                result = dlg.choice(comment, choices, defopt)
            else:
                raise RuntimeError("Bad method: %s" % vartype)
            outf.write('%s = %s\n' % (varname, result))
            # Remeber the selected value
            defaults[varname] = result
            # Clear cumulated values
            comment = ''
            default = None
            choices = []
            continue
       
        if line.startswith('@'):
            # Add new line into the 'choice array' 
            res = re.match(r'@\s*(?:\[(.*?)\])?\s*"(.*?)"\s*(.*)$', line)
            if not res:
                raise RuntimeError("Bad line: %s" % line)
            if res.group(1):
                if not check_condition(res.group(1),defaults):
                    continue
            choices.append((res.group(2), res.group(3)))
            continue
 
        # All other things print to output file
        outf.write(line)
        if re.match(r'^#[^#]', line):
            # Last comment before question will be displayed to the user
            comment = line[1:].strip()
        elif line.startswith('##'):
            # Set title of the dialog window
            dlg.set_title(line[2:].strip())
       
    outf.close()
    f.close()
 
def main():
    defaults = {}
    try:
        dlg = Dialog()
    except NotImplementedError:
        dlg = NoDialog()
 
    # Default run will update the configuration file
    # with newest options
 
 
    if len(sys.argv) == 2 and sys.argv[1]=='default':
        dlg = DefaultDialog(dlg)
 
    if os.path.exists(OUTPUT):
        read_defaults(OUTPUT, defaults)
   
    parse_config(INPUT, TMPOUTPUT, dlg, defaults)
    if os.path.exists(OUTPUT):
        os.unlink(OUTPUT)
    os.rename(TMPOUTPUT, OUTPUT)
       
 
if __name__ == '__main__':
    main()
 

Rev 549	Rev 550
1	#!/usr/bin/env python	1	#!/usr/bin/env python
2	"""	2	"""
3	Kernel configuration script	3	Kernel configuration script
4	"""	4	"""
5	import sys	5	import sys
6	import os	6	import os
7	import re	7	import re
8		8
9	INPUT = 'kernel.config'	9	INPUT = 'kernel.config'
10	OUTPUT = 'Makefile.config'	10	OUTPUT = 'Makefile.config'
11	TMPOUTPUT = 'Makefile.config.tmp'	11	TMPOUTPUT = 'Makefile.config.tmp'
12		12
13	class DefaultDialog:	13	class DefaultDialog:
14	"Wrapper dialog that tries to return default values"	14	"Wrapper dialog that tries to return default values"
15	def __init__(self, dlg):	15	def __init__(self, dlg):
16	self.dlg = dlg	16	self.dlg = dlg
17		17
18	def set_title(self,text):	18	def set_title(self,text):
19	self.dlg.set_title(text)	19	self.dlg.set_title(text)
20		20
21	def yesno(self, text, default=None):	21	def yesno(self, text, default=None):
22	if default is not None:	22	if default is not None:
23	return default	23	return default
24	return self.dlg.yesno(text, default)	24	return self.dlg.yesno(text, default)
25	def noyes(self, text, default=None):	25	def noyes(self, text, default=None):
26	if default is not None:	26	if default is not None:
27	return default	27	return default
28	return self.dlg.noyes(text, default)	28	return self.dlg.noyes(text, default)
29		29
30	def choice(self, text, choices, defopt=None):	30	def choice(self, text, choices, defopt=None):
31	if defopt is not None:	31	if defopt is not None:
32	return choices[defopt][0]	32	return choices[defopt][0]
33	return self.dlg.choice(text, choices, defopt)	33	return self.dlg.choice(text, choices, defopt)
34		34
35	class NoDialog:	35	class NoDialog:
36	def __init__(self):	36	def __init__(self):
37	self.printed = None	37	self.printed = None
38	self.title = 'HelenOS Configuration'	38	self.title = 'HelenOS Configuration'
39		39
40	def print_title(self):	40	def print_title(self):
41	if not self.printed:	41	if not self.printed:
42	sys.stdout.write("* %s *\n" % self.title)	42	sys.stdout.write("* %s *\n" % self.title)
43	self.printed = True	43	self.printed = True
44		44
45	def set_title(self, text):	45	def set_title(self, text):
46	self.title = text	46	self.title = text
47	self.printed = False	47	self.printed = False
48		48
49	def noyes(self, text, default=None):	49	def noyes(self, text, default=None):
50	if not default:	50	if not default:
51	default = 'n'	51	default = 'n'
52	return self.yesno(text, default)	52	return self.yesno(text, default)
53		53
54	def yesno(self, text, default=None):	54	def yesno(self, text, default=None):
55	self.print_title()	55	self.print_title()
56		56
57	if default != 'n':	57	if default != 'n':
58	default = 'y'	58	default = 'y'
59	while 1:	59	while 1:
60	sys.stdout.write("%s (y/n)[%s]: " % (text,default))	60	sys.stdout.write("%s (y/n)[%s]: " % (text,default))
61	inp = sys.stdin.readline()	61	inp = sys.stdin.readline()
62	if not inp:	62	if not inp:
63	raise EOFError	63	raise EOFError
64	inp = inp.strip().lower()	64	inp = inp.strip().lower()
65	if not inp:	65	if not inp:
66	return default	66	return default
67	if inp == 'y':	67	if inp == 'y':
68	return 'y'	68	return 'y'
69	elif inp == 'n':	69	elif inp == 'n':
70	return 'n'	70	return 'n'
71		71
72	def _print_choice(self, text, choices, defopt):	72	def _print_choice(self, text, choices, defopt):
73	sys.stdout.write('%s:\n' % text)	73	sys.stdout.write('%s:\n' % text)
74	for i,(text,descr) in enumerate(choices):	74	for i,(text,descr) in enumerate(choices):
75	sys.stdout.write('\t%2d. %s\n' % (i, descr))	75	sys.stdout.write('\t%2d. %s\n' % (i, descr))
76	if defopt is not None:	76	if defopt is not None:
77	sys.stdout.write('Enter choice number[%d]: ' % defopt)	77	sys.stdout.write('Enter choice number[%d]: ' % defopt)
78	else:	78	else:
79	sys.stdout.write('Enter choice number: ')	79	sys.stdout.write('Enter choice number: ')
80		80
81	def choice(self, text, choices, defopt=None):	81	def choice(self, text, choices, defopt=None):
82	self.print_title()	82	self.print_title()
83	while 1:	83	while 1:
84	self._print_choice(text, choices, defopt)	84	self._print_choice(text, choices, defopt)
85	inp = sys.stdin.readline()	85	inp = sys.stdin.readline()
86	if not inp:	86	if not inp:
87	raise EOFError	87	raise EOFError
88	if not inp.strip():	88	if not inp.strip():
89	if defopt is not None:	89	if defopt is not None:
90	return choices[defopt][0]	90	return choices[defopt][0]
91	continue	91	continue
92	try:	92	try:
93	number = int(inp.strip())	93	number = int(inp.strip())
94	except ValueError:	94	except ValueError:
95	continue	95	continue
96	if number < 0 or number >= len(choices):	96	if number < 0 or number >= len(choices):
97	continue	97	continue
98	return choices[number][0]	98	return choices[number][0]
99		99
100		100
101	class Dialog(NoDialog):	101	class Dialog(NoDialog):
102	def __init__(self):	102	def __init__(self):
103	NoDialog.__init__(self)	103	NoDialog.__init__(self)
104	self.dlgcmd = os.environ.get('DIALOG','dialog')	104	self.dlgcmd = os.environ.get('DIALOG','dialog')
105	self.title = 'HelenOS Configuration'	105	self.title = 'HelenOS Configuration'
106		106
107	if os.system('%s --print-maxsize >/dev/null 2>&1' % self.dlgcmd) != 0:	107	if os.system('%s --print-maxsize >/dev/null 2>&1' % self.dlgcmd) != 0:
108	raise NotImplementedError	108	raise NotImplementedError
109		109
110	def set_title(self,text):	110	def set_title(self,text):
111	self.title = text	111	self.title = text
112		112
113	def calldlg(self,args,*kw):	113	def calldlg(self,args,*kw):
114	"Wrapper for calling 'dialog' program"	114	"Wrapper for calling 'dialog' program"
115	indesc, outdesc = os.pipe()	115	indesc, outdesc = os.pipe()
116	pid = os.fork()	116	pid = os.fork()
117	if not pid:	117	if not pid:
118	os.close(2)	118	os.close(2)
119	os.dup(outdesc)	119	os.dup(outdesc)
120	os.close(indesc)	120	os.close(indesc)
121		121
122	dlgargs = [self.dlgcmd,'--title',self.title]	122	dlgargs = [self.dlgcmd,'--title',self.title]
123	for key,val in kw.items():	123	for key,val in kw.items():
124	dlgargs.append('--'+key)	124	dlgargs.append('--'+key)
125	dlgargs.append(val)	125	dlgargs.append(val)
126	dlgargs += args	126	dlgargs += args
127	os.execlp(self.dlgcmd,*dlgargs)	127	os.execlp(self.dlgcmd,*dlgargs)
128		128
129	os.close(outdesc)	129	os.close(outdesc)
130	errout = os.fdopen(indesc,'r')	130	errout = os.fdopen(indesc,'r')
131	data = errout.read()	131	data = errout.read()
132	errout.close()	132	errout.close()
133		133
134	pid,status = os.wait()	134	pid,status = os.wait()
135	if not os.WIFEXITED(status):	135	if not os.WIFEXITED(status):
136	raise EOFError	136	raise EOFError
137	status = os.WEXITSTATUS(status)	137	status = os.WEXITSTATUS(status)
138	if status == 255:	138	if status == 255:
139	raise EOFError	139	raise EOFError
140	return status,data	140	return status,data
141		141
142	def yesno(self, text, default=None):	142	def yesno(self, text, default=None):
143	text = text + ':'	143	text = text + ':'
144	width = '50'	144	width = '50'
145	height = '5'	145	height = '5'
146	if len(text) < 48:	146	if len(text) < 48:
147	text = ' '*int(((48-len(text))/2)) + text	147	text = ' '*int(((48-len(text))/2)) + text
148	else:	148	else:
149	width = '0'	149	width = '0'
150	height = '0'	150	height = '0'
151	if default == 'n':	151	if default == 'n':
152	res,data = self.calldlg('--defaultno','--yesno',text,height,width)	152	res,data = self.calldlg('--defaultno','--yesno',text,height,width)
153	else:	153	else:
154	res,data = self.calldlg('--yesno',text,height,width)	154	res,data = self.calldlg('--yesno',text,height,width)
155		155
156	if res == 0:	156	if res == 0:
157	return 'y'	157	return 'y'
158	return 'n'	158	return 'n'
159		159
160	def choice(self, text, choices, defopt=None):	160	def choice(self, text, choices, defopt=None):
161	text = text + ':'	161	text = text + ':'
162	width = '50'	162	width = '50'
163	height = str(8 + len(choices))	163	height = str(8 + len(choices))
164	args = []	164	args = []
165	for key,val in choices:	165	for key,val in choices:
166	args.append(key)	166	args.append(key)
167	args.append(val)	167	args.append(val)
168		168
169	kw = {}	169	kw = {}
170	if defopt:	170	if defopt:
171	kw['default-item'] = choices[defopt][0]	171	kw['default-item'] = choices[defopt][0]
172	res,data = self.calldlg('--nocancel','--menu',text,height,width,	172	res,data = self.calldlg('--nocancel','--menu',text,height,width,
173	str(len(choices)),args, *kw)	173	str(len(choices)),args, *kw)
174	if res:	174	if res:
175	print data	175	print data
176	raise EOFError	176	raise EOFError
177	return data	177	return data
178		178
179	def read_defaults(fname,defaults):	179	def read_defaults(fname,defaults):
180	"Read saved values from last configuration run"	180	"Read saved values from last configuration run"
181	f = file(fname,'r')	181	f = file(fname,'r')
182	for line in f:	182	for line in f:
183	res = re.match(r'^(?:#!# )?([^#]\w)\s=\s(.?)\s*$', line)	183	res = re.match(r'^(?:#!# )?([^#]\w)\s=\s(.?)\s*$', line)
184	if res:	184	if res:
185	defaults[res.group(1)] = res.group(2)	185	defaults[res.group(1)] = res.group(2)
186	f.close()	186	f.close()
187		187
188	def check_condition(text, defaults):	188	def check_condition(text, defaults):
-		189	result = True
-		190	conds = text.split('&')
-		191	for cond in conds:
-		192	if cond.startswith('(') and cond.endswith(')'):
-		193	cond = cond[1:-1]
-		194	if not check_dnf(cond, defaults):
-		195	return False
-		196	return True
-		197
-		198	def check_dnf(text, defaults):
-		199	"""
189	"Check that the condition specified on input line is True"	200	Check that the condition specified on input line is True
-		201
190	result = False	202	only CNF is supported
-		203	"""
191	conds = text.split('\|')	204	conds = text.split('\|')
192	for cond in conds:	205	for cond in conds:
-		206	res = re.match(r'^(.?)(!?=)(.)$', cond)
-		207	if not res:
-		208	raise RuntimeError("Invalid condition: %s" % cond)
193	condname,condval = cond.split('=')	209	condname = res.group(1)
-		210	oper = res.group(2)
-		211	condval = res.group(3)
194	if not defaults.has_key(condname):	212	if not defaults.has_key(condname):
195	raise RuntimeError("Condition var %s does not exist: %s" % \	213	raise RuntimeError("Condition var %s does not exist: %s" % \
196	(condname,line))	214	(condname,text))
197	# None means wildcard	-
-		215
198	if defaults[condname] is None:	216	if oper=='=' and condval == defaults[condname]:
199	return True	217	return True
200	if condval == defaults[condname]:	218	if oper == '!=' and condval != defaults[condname]:
201	return True	219	return True
202	return False	220	return False
203		221
204	def parse_config(input, output, dlg, defaults={}):	222	def parse_config(input, output, dlg, defaults={}):
205	"Parse configuration file and create Makefile.config on the fly"	223	"Parse configuration file and create Makefile.config on the fly"
206	f = file(input, 'r')	224	f = file(input, 'r')
207	outf = file(output, 'w')	225	outf = file(output, 'w')
208		226
209	outf.write('#########################################\n')	227	outf.write('#########################################\n')
210	outf.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')	228	outf.write('## AUTO-GENERATED FILE, DO NOT EDIT!!! ##\n')
211	outf.write('#########################################\n\n')	229	outf.write('#########################################\n\n')
212		230
213	comment = ''	231	comment = ''
214	default = None	232	default = None
215	choices = []	233	choices = []
216	for line in f:	234	for line in f:
-		235	if line.startswith('%'):
-		236	res = re.match(r'^%\s(?:\[(.?)\])?\s(.)$', line)
-		237	if not res:
-		238	raise RuntimeError('Invalid command: %s' % line)
-		239	if res.group(1):
-		240	if not check_condition(res.group(1), defaults):
-		241	continue
-		242	args = res.group(2).strip().split(' ')
-		243	cmd = args[0].lower()
-		244	args = args[1:]
-		245	if cmd == 'askdefault':
-		246	if isinstance(dlg, DefaultDialog):
-		247	continue
-		248	res = dlg.noyes('Change kernel configuration')
-		249	if res == 'n':
-		250	dlg = DefaultDialog(dlg)
-		251	elif cmd == 'saveas':
-		252	outf.write('%s = %s\n' % (args[1],defaults[args[0]]))
-		253
-		254	continue
-		255
217	if line.startswith('!'):	256	if line.startswith('!'):
218	# Ask a question	257	# Ask a question
219	res = re.search(r'!\s(?:\[(.?)\])?\s([^\s]+)\s\((.)\)\s$', line)	258	res = re.search(r'!\s(?:\[(.?)\])?\s([^\s]+)\s\((.)\)\s$', line)
220	if not res:	259	if not res:
221	raise RuntimeError("Weird line: %s" % line)	260	raise RuntimeError("Weird line: %s" % line)
222	varname = res.group(2)	261	varname = res.group(2)
223	vartype = res.group(3)	262	vartype = res.group(3)
224		263
225	default = defaults.get(varname,None)	264	default = defaults.get(varname,None)
226		265
227	if res.group(1):	266	if res.group(1):
228	if not check_condition(res.group(1), defaults):	267	if not check_condition(res.group(1), defaults):
229	if default is not None:	268	if default is not None:
230	outf.write('#!# %s = %s\n' % (varname, default))	269	outf.write('#!# %s = %s\n' % (varname, default))
-		270	# Clear cumulated values
-		271	comment = ''
-		272	default = None
-		273	choices = []
231	continue	274	continue
232		275
233	if vartype == 'y/n':	276	if vartype == 'y/n':
234	result = dlg.yesno(comment, default)	277	result = dlg.yesno(comment, default)
235	elif vartype == 'n/y':	278	elif vartype == 'n/y':
236	result = dlg.noyes(comment, default)	279	result = dlg.noyes(comment, default)
237	elif vartype == 'choice':	280	elif vartype == 'choice':
238	defopt = None	281	defopt = None
239	if default is not None:	282	if default is not None:
240	for i,(key,val) in enumerate(choices):	283	for i,(key,val) in enumerate(choices):
241	if key == default:	284	if key == default:
242	defopt = i	285	defopt = i
243	break	286	break
244	result = dlg.choice(comment, choices, defopt)	287	result = dlg.choice(comment, choices, defopt)
245	else:	288	else:
246	raise RuntimeError("Bad method: %s" % vartype)	289	raise RuntimeError("Bad method: %s" % vartype)
247	outf.write('%s = %s\n' % (varname, result))	290	outf.write('%s = %s\n' % (varname, result))
248	# Remeber the selected value	291	# Remeber the selected value
249	defaults[varname] = result	292	defaults[varname] = result
250	# Clear cumulated values	293	# Clear cumulated values
251	comment = ''	294	comment = ''
252	default = None	295	default = None
253	choices = []	296	choices = []
254	continue	297	continue
255		298
256	if line.startswith('@'):	299	if line.startswith('@'):
257	# Add new line into the 'choice array'	300	# Add new line into the 'choice array'
258	res = re.match(r'@\s(?:\[(.?)\])?\s"(.?)"\s(.)$', line)	301	res = re.match(r'@\s(?:\[(.?)\])?\s"(.?)"\s(.)$', line)
259	if not res:	302	if not res:
260	raise RuntimeError("Bad line: %s" % line)	303	raise RuntimeError("Bad line: %s" % line)
261	if res.group(1):	304	if res.group(1):
262	if not check_condition(res.group(1),defaults):	305	if not check_condition(res.group(1),defaults):
263	continue	306	continue
264	choices.append((res.group(2), res.group(3)))	307	choices.append((res.group(2), res.group(3)))
265	continue	308	continue
266		309
267	# All other things print to output file	310	# All other things print to output file
268	outf.write(line)	311	outf.write(line)
269	if re.match(r'^#[^#]', line):	312	if re.match(r'^#[^#]', line):
270	# Last comment before question will be displayed to the user	313	# Last comment before question will be displayed to the user
271	comment = line[1:].strip()	314	comment = line[1:].strip()
272	elif line.startswith('##'):	315	elif line.startswith('##'):
273	# Set title of the dialog window	316	# Set title of the dialog window
274	dlg.set_title(line[2:].strip())	317	dlg.set_title(line[2:].strip())
275		318
276	outf.close()	319	outf.close()
277	f.close()	320	f.close()
278		321
279	def main():	322	def main():
280	defaults = {'ARCH':None}	323	defaults = {}
281	try:	324	try:
282	dlg = Dialog()	325	dlg = Dialog()
283	except NotImplementedError:	326	except NotImplementedError:
284	dlg = NoDialog()	327	dlg = NoDialog()
285		328
286	# Default run will update the configuration file	329	# Default run will update the configuration file
287	# with newest options	330	# with newest options
288	if len(sys.argv) >= 2:	-
289	defaults['ARCH'] = sys.argv[1]	-
290	if len(sys.argv) == 3 and sys.argv[2]=='default':	331	if len(sys.argv) == 2 and sys.argv[1]=='default':
291	dlg = DefaultDialog(dlg)	332	dlg = DefaultDialog(dlg)
292		333
293	if os.path.exists(OUTPUT):	334	if os.path.exists(OUTPUT):
294	read_defaults(OUTPUT, defaults)	335	read_defaults(OUTPUT, defaults)
295		336
296	parse_config(INPUT, TMPOUTPUT, dlg, defaults)	337	parse_config(INPUT, TMPOUTPUT, dlg, defaults)
297	if os.path.exists(OUTPUT):	338	if os.path.exists(OUTPUT):
298	os.unlink(OUTPUT)	339	os.unlink(OUTPUT)
299	os.rename(TMPOUTPUT, OUTPUT)	340	os.rename(TMPOUTPUT, OUTPUT)
300		341
301		342
302	if __name__ == '__main__':	343	if __name__ == '__main__':
303	main()	344	main()
304		345

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/tools/config.py @ 720 – Rev 549 → 550