New option stuff.

git-svn-id: svn://svn.coreboot.org/coreboot/trunk@891 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

1 files changed, 547 insertions, 286 deletions

diff --git a/util/newconfig/config.g b/util/newconfig/config.g
index 4222f57630..a2bafd3d95 100644
--- a/util/newconfig/config.g
+++ b/util/newconfig/config.g
@@ -3,10 +3,9 @@ import os
 import re
 import string
 
-debug = 3
+debug = 0
 
 arch = ''
-makebase = ''
 ldscriptbase = ''
 payloadfile = ''
 
@@ -29,6 +28,7 @@ driverrules = {}
 ldscripts = []
 userdefines = []
 curpart = 0
+root = 0
 
 globalvars = {}       # We will globals here
 parts = {}
@@ -104,53 +104,116 @@ class makerule:
 
 class option:
 	def __init__ (self, name):
-		self.name = name
-		self.loc = 0
-		self.value = 0
-		self.set = 0
-		self.default = 0
+		self.name = name	# name of option
+		self.loc = 0		# current location
+		self.value = 0		# option value
+		self.set = 0		# option has been set
+		self.default = 0	# option has default value (otherwise
+					# it is undefined)
+		self.comment = ''	# description of option
+		self.export = 0		# option is able to be exported
+		self.exported = 0	# option is exported
+		self.defined = 0	# option has a value
+		self.format = '%s'	# option print format
 
 	def setvalue(self, value, loc):
 		if (self.set):
-			print "Option %s: \n" % self.name
-			print "Attempt to set %s at %s\n" % (value, loc.at()) 
-			print "Already set to %s at %s\n" % \
+			print "Option %s: " % self.name
+			print "Attempt to set %s at %s" % (value, loc.at()) 
+			print "Already set to %s at %s" % \
 					(self.value, self.loc.at())
 			sys.exit(1)
 		self.set = 1
 		self.value = value
+		self.defined = 1
 		self.loc = loc
 
-
-	def getvalue(self):
-		self.set = 1
-		return self.value
+	def getvalue(self, part):
+		global curpart
+		if (not (type(self.value) is str)):
+			return self.value
+		if (self.value == '' or self.value[0] != '{'):
+			return self.value
+		# evaluate expression
+		a = re.sub("^{", "", self.value)
+		a = re.sub("}$", "", a)
+		# save curpart so we can evaluate expression
+		# in context of part
+		s = curpart
+		curpart = part
+		v = parse('value', a)
+		curpart = s
+		return v
 
 	def setdefault(self, value, loc):
 		if (self.default):
 			print "%s: " % self.name
-			print "Attempt to default %s at %s\n" % (value, loc) 
-			print "Already defaulted to %s at %s\n" %  \
+			print "Attempt to default %s at %s" % (value, loc) 
+			print "Already defaulted to %s at %s" %  \
 					(self.value, self.loc.at())
-			print "Warning only\n"
+			print "Warning only"
 		if (self.set):
 			print "%s: " % self.name
-			print "Attempt to default %s at %s\n" % (value, loc) 
-			print "Already set to %s at %s\n" % \
+			print "Attempt to default %s at %s" % (value, loc) 
+			print "Already set to %s at %s" % \
 					(self.value, self.loc.at())
-			print "Warning only\n"
+			print "Warning only"
 			return
-		self.default = 1
 		self.value = value
+		self.defined = 1
+		self.default = 1
 		self.loc = loc
+
+	def setnodefault(self, loc):
+		self.default = 1
+		self.defined = 0
+		self.loc = loc
+
 	def where(self):
 		return self.loc
 
+	def setcomment(self, value, loc):
+		if (self.comment != ''):
+			print "%s: " % self.name
+			print "Attempt to modify comment at %s" % loc 
+			return
+		self.comment = value
+
+	def setexport(self):
+		self.export = 1
+
+	def setexported(self):
+		self.export = 1
+		self.exported = 1
+
+	def setnoexport(self):
+		self.export = 0
+		self.exported = 0
+
+	def setformat(self, fmt):
+		self.format = fmt
+
+	def getformat(self):
+		return self.format
+
+	def used(self):
+		if (self.export):
+			self.exported = 1
+
+	def isexported(self):
+		return (self.exported and self.defined)
+
+	def isdefined(self):
+		return (self.defined)
+
+	def isset(self):
+		return (self.set)
 
 class partobj:
 	def __init__ (self, dir, parent, type):
 		global partinstance
-		print "partobj dir %s parent %s type %s" %(dir,parent,type)
+		if (debug):
+			print "partobj dir %s parent %s type %s" %(dir,parent,type)
 		self.children = []
 		self.initcode = []
 		self.registercode = []
@@ -163,8 +226,10 @@ class partobj:
 		partinstance = partinstance + 1
 		self.devfn = 0	
 		self.private = 0	
+		self.options = {}
 		if (parent):
-			print "add to parent"
+			if (debug):
+				print "add to parent"
 			self.parent   = parent
 			parent.children.append(self)
 		else:
@@ -177,10 +242,10 @@ class partobj:
 		print "%d: parent dir %s" % (lvl,self.parent.dir)
 		print "%d: initcode " % lvl
 		for i in self.initcode:
-			print "  %s\n" % i
+			print "  %s" % i
 		print "%d: registercode " % lvl
 		for i in self.registercode:
-			print "  %s\n" % i
+			print "  %s" % i
 
 	def gencode(self):
 		print "struct cdev dev%d = {" % self.instance
@@ -204,8 +269,16 @@ class partobj:
 		
     	def addregister(self, code):
         	self.registercode.append(code)
-		
-	
+
+	def usesoption(self, name):
+		o = getvalue(options, name)
+		if (o == 0):
+			fatal("Error: can't use undefined option %s" % name)
+		o.used()
+		setvalue(self.options, name, o)
+		if (debug):
+			print "option %s used in %s" % (name, self)
+
 class partsstack:
 	def __init__ (self):
 		self.stack = []
@@ -246,21 +319,24 @@ def warning(string):
 # -----------------------------------------------------------------------------
 
 def getvalue(dict, name):
-    if name not in dict.keys(): print 'Undefined:', name
-    v = dict.get(name, 0)
-    if (debug > 1):
-	print "getvalue %s returning %s\n" % (name, v)
-    return v
+	if name not in dict.keys(): 
+		if (debug >1):
+			print 'Undefined:', name
+		return 0
+	v = dict.get(name, 0)
+	if (debug > 1):
+		print "getvalue %s returning %s" % (name, v)
+	return v
 
 def setvalue(dict, name, value):
-	print "name %s value %s" % (name, value)
-	if name in dict.keys(): print "Warning, %s previously defined" % name
+	if name in dict.keys(): 
+		print "Warning, %s previously defined" % name
     	if (debug > 1):
-		print "setvalue sets %s to %s\n" % (name, value)
+		print "setvalue sets %s to %s" % (name, value)
 	dict[name] = value
 
 # options. 
-# to create an option, it has to no exist. 
+# to create an option, it has to not exist. 
 # When an option value is fetched, the fact that it was used is 
 # remembered. 
 # Legal things to do:
@@ -269,38 +345,157 @@ def setvalue(dict, name, value):
 # Illegal:
 # use the value, then try to set the value
 
-def getoption(name):
-	print "getoption %s" % name
+def newoption(name):
 	o = getvalue(options, name)
-	if (o == 0):
-		fatal( "Error. Option %s Undefined. Fix me.\n" % name)
+	if (o):
+		print "option %s already defined" % name
+		sys.exit(1)
+	o = option(name)
+	setvalue(options, name, o)
+	options_by_order.append(name)
+
+# option must be declared before being used in a part
+# if we're not processing a part, then we must
+# be at the top level where all options are available
+def getoption(name, part):
+	global options
+	if (part):
+		o = getvalue(part.options, name)
+	else:
+		o = getvalue(options, name)
+	if (o == 0 or not o.defined):
+		fatal( "Error: Option %s Undefined." % name)
+	v = o.getvalue(part)
 	if (debug > 2):
-		print "returns %s" % o
+		print "getoption returns %s" % v
 		print "%s" % o.where()
-	return o.getvalue()
+	return v
+
+# setoptionstmt only allowed at top level
+def setoptionstmt(name, value):
+	global curpart
+	if (curpart != root):
+		fatal("Error: options can only be set in target configuration file")
+	setoption(name, value)
 
-# stupid code, refactor later. 
 def setoption(name, value):
+	global loc
 	o = getvalue(options, name)
-	if (o):
-		o.setvalue(value, loc)
-		return
-	o = option(name)
+	if (o == 0):
+		fatal("Error: attempt set nonexistent option %s" % name)
 	o.setvalue(value, loc)
-	setvalue(options, name, o)
-	options_by_order.append(name)
 
 def setdefault(name, value):
+	global loc
 	o = getvalue(options, name)
-	if (o):
-		o.setdefault(value, loc)
+	if (not o):
+		return
+	if (o.default):
+		print "setdefault: attempt to duplicate default for %s" % name
 		return
-	print "setdefault: %s not here, setting to %s" % \
-			(name, value)
-	o = option(name)
 	o.setdefault(value, loc)
-	setvalue(options, name, o)
-	options_by_order.append(name)
+
+def setnodefault(name):
+	global loc
+	o = getvalue(options, name)
+	if (not o):
+		return
+	if (o.default):
+		print "setdefault: attempt to duplicate default for %s" % name
+		return
+	o.setnodefault(loc)
+
+def setcomment(name, value):
+	o = getvalue(options, name)
+	if (not o):
+		fatal("setcomment: %s not here" % name)
+	o.setcomment(value, loc)
+
+def setexported(name):
+	o = getvalue(options, name)
+	if (not o):
+		fatal("setexported: %s not here" % name)
+	o.setexported()
+
+def setnoexport(name):
+	o = getvalue(options, name)
+	if (not o):
+		fatal("setnoexport: %s not here" % name)
+	o.setnoexport()
+
+def setexport(name):
+	o = getvalue(options, name)
+	if (not o):
+		fatal("setexport: %s not here" % name)
+	o.setexport()
+
+def setformat(name, fmt):
+	o = getvalue(options, name)
+	if (not o):
+		fatal("setexport: %s not here" % name)
+	o.setformat(fmt)
+
+def getformated(name, part):
+	global options
+	if (part):
+		o = getvalue(part.options, name)
+	else:
+		o = getvalue(options, name)
+	if (o == 0 or not o.defined):
+		fatal( "Error: Option %s Undefined." % name)
+	v = o.getvalue(part)
+	f = o.getformat()
+	return (f % v)
+
+def isexported(name, part):
+	if (part):
+		o = getvalue(part.options, name)
+	else:
+		o = getvalue(options, name)
+	if (o):
+		return o.isexported()
+	return 0
+
+def isdefined(name, part):
+	if (part):
+		o = getvalue(part.options, name)
+	else:
+		o = getvalue(options, name)
+	if (o):
+		return o.isdefined()
+	return 0
+
+def isset(name, part):
+	if (part):
+		o = getvalue(part.options, name)
+	else:
+		o = getvalue(options, name)
+	if (o):
+		return o.isset()
+	return 0
+
+def usesoption(name):
+	global curpart
+	curpart.usesoption(name)
+
+def validdef(name, defval):
+	o = getvalue(options, name)
+	if (not o):
+		fatal("validdef: %s not here" % name)
+	if ((defval & 1) != 1):
+	    fatal("Error: must specify default value for option %s" % name)
+	if ((defval & 2) != 2):
+	    fatal("Error: must specify export for option %s" % name)
+	if ((defval & 4) != 4):
+	    fatal("Error: must specify comment for option %s" % name)
+
+def loadoptions():
+	global treetop
+	optionsfile = os.path.join(treetop, 'src', 'config', 'Options.lb')
+	loc.push_file(optionsfile)
+	if (not parse('options', open(optionsfile, 'r').read())):
+		fatal("Error: Could not parse file")
+	loc.pop_file()
 
 # we do the crt0include as a dictionary, so that if needed we
 # can trace who added what when. Also it makes the keys
@@ -314,7 +509,7 @@ def addcrt0include(path):
 	# later. 
 	fullpath = path
 	if (debug > 2):
-		print "ADDCRT0: %s\n" % fullpath
+		print "ADDCRT0: %s" % fullpath
 	crt0includes.append(fullpath)
 
 def addldscript(path):
@@ -326,7 +521,7 @@ def addldscript(path):
 	#fullpath = os.path.join(curdir, path)
 	#setvalue(ldscripts, fullpath, loc)
 	if (debug):
-		print "fullpath :%s: curdir :%s: path :%s:\n" % (fullpath, curdir, path)
+		print "fullpath :%s: curdir :%s: path :%s:" % (fullpath, curdir, path)
 	ldscripts.append(fullpath)
 
 def payload(path):
@@ -342,7 +537,6 @@ def payload(path):
 # such kludgery. If the name starts with '.' then make the 
 # dependency be on ./thing.x gag me.
 def addobjectdriver(dict, object_name):
-	print "add object object_name %s" % object_name
 	suffix = object_name[-2:]
 	if (suffix == '.o'):
 		suffix = '.c'
@@ -352,7 +546,8 @@ def addobjectdriver(dict, object_name):
 	else:
 		source = os.path.join(curdir, base + suffix)
 	object = base + '.o'
-	print "addobject %s source %s\n" % (object, source)
+	if (debug):
+		print "add object %s source %s" % (object_name, source)
 	setvalue(dict, base, [object, source])
 
 def addobject(object_name):
@@ -364,42 +559,34 @@ def adddriver(driver_name):
 def target(targ_name):
         global target_dir
 	global curpart
-	print "TARGET loc.file is %s\n" % loc.file()
+	global root
+	print "Configuring TARGET %s" % targ_name
         target_dir = os.path.join(os.path.dirname(loc.file()), targ_name)
-	print "TARGET dir.loc.file is %s\n" % os.path.dirname(loc.file())
         if not os.path.isdir(target_dir):
-                print 'Creating directory', target_dir
+                print "Creating directory" % target_dir
                 os.makedirs(target_dir)
-        print 'Will place Makefile, crt0.S, etc. in ', target_dir
-	print '%s\n' % loc.file()
-	board = partobj(target_dir, 0, 'board')
-	curpart = board
-
-
+        print "Will place Makefile, crt0.S, etc. in %s" % target_dir
+	root = partobj(target_dir, 0, 'board')
+	curpart = root
 
 def part(name, path, file):
-	global curpart,curdir
-	if (debug):
-		print "%s " % name
+	global curpart,curdir,treetop
 	dirstack.append(curdir)
 	curdir = os.path.join(treetop, 'src', name, path)
 	newpart = partobj(curdir, curpart, name)
-	print "PUSH part " , curpart.dir
+	print "Configuring PART %s" % name
+	if (debug):
+		print "PUSH part %s %s" % (name, curpart.dir)
 	pstack.push(curpart)
 	curpart = newpart
-	#	option(parts, name, path)
-	# open the file, and parse it. 
-#        curpart.option('MAINBOARD_PART_NUMBER', 
-#			os.path.basename(lookup(parts, 'mainboard')))
-#        option(options, 'MAINBOARD_VENDOR', os.path.dirname(getvalue(parts, 'mainboard')))
-
 	doconfigfile(curdir, file)
 
 def partpop():
 	global curpart,curdir
 	curpart = pstack.pop()
 	curdir = dirstack.pop()
-	print "POP PART %s\n" % curpart.dir
+	if (debug):
+		print "POP PART %s" % curpart.dir
 
 # dodir is like part but there is no new part
 def dodir(path, file):
@@ -412,8 +599,8 @@ def dodir(path, file):
 	else:
 		fullpath = os.path.join(curdir,  path)
 	if (debug):
-		print "DODIR: path %s, fullpath %s\n" % (path, fullpath)
-		print "DODIR: curdis %s treetop %s\n" % (curdir, treetop)
+		print "DODIR: path %s, fullpath %s" % (path, fullpath)
+		print "DODIR: curdis %s treetop %s" % (curdir, treetop)
 	dirstack.append(curdir)
 	curdir = fullpath
 	file = os.path.join(fullpath, file)
@@ -422,15 +609,20 @@ def dodir(path, file):
 	curdir = dirstack.pop()
 
 def ternary(expr, yes, no):
-	print "ternary %s" % expr
+	if (debug):
+		print "ternary %s" % expr
         a = tohex(expr) # expr # eval(expr)
-        print "expr %s a %d yes %d no %d\n"% (expr, a, yes, no)
+	if (debug):
+		print "expr %s a %d yes %d no %d"% (expr, a, yes, no)
         if (a == 0):
-	    print "Ternary returns %d\n" % yes
-            return yes
+		if (debug):
+		    print "Ternary returns %d" % yes
+		return yes
         else:
-	    print "Ternary returns %d\n" % no
-            return no
+		if (debug):
+			print "Ternary returns %d" % no
+		return no
+
 # atoi is in the python library, but not strtol? Weird!
 def tohex(name):
 	return eval('int(%s)' % name)
@@ -479,23 +671,24 @@ def topify(path):
 
 # arch is 'different' ... darn it.
 def set_arch(my_arch):
-	global arch, makebase
+	global arch
 	global curdir
 	arch = my_arch
-	setdefault('ARCH', my_arch)
+	setoption('ARCH', my_arch)
 	part('arch', my_arch, 'config/make.base.lb')
 
 
 def mainboard(path):
-	global mainboard_dir
+	global mainboard_dir, treetop
 	mainboard_dir = path
 	full_mainboard_dir = os.path.join(treetop, 'src/mainboard', path)
-	setdefault('MAINBOARD', full_mainboard_dir)
+	setoption('MAINBOARD', full_mainboard_dir)
         vendor = re.sub("/.*", "", path)
         mainboard_part_number = re.sub("[^/]/", "", path)
-	setdefault('MAINBOARD_VENDOR', vendor)
-	setdefault('MAINBOARD_PART_NUMBER', mainboard_part_number)
+	setoption('MAINBOARD_VENDOR', vendor)
+	setoption('MAINBOARD_PART_NUMBER', mainboard_part_number)
 	part('mainboard', path, 'Config.lb')
+
 #=============================================================================
 #		FILE OUTPUT 
 #=============================================================================
@@ -506,7 +699,7 @@ def writemakefileheader(file, fname):
 
 
 def writemakefilesettings(path):
-	global treetop, arch, mainboard_dir, target_dir, options
+	global treetop, arch, mainboard_dir, target_dir, options_by_order, root
 	# Write Makefile.settings to seperate the settings
 	# from the actual makefile creation
 	# In practice you need to rerun NLBConfig.py to change
@@ -521,25 +714,19 @@ def writemakefilesettings(path):
 	#file.write("MAINBOARD:=%s\n" % (mainboard_dir))
 	file.write("TARGET_DIR:=%s\n" % (target_dir))
 	for i in options_by_order:
-		o = options[i]
-		# get the number in hex
-		v =  o.getvalue()
-		if IsInt(v):
-			vi = int(v)
-			s = "export %s:=0x%x\n"% (i, vi)
-			file.write(s)
-		else:
-			file.write("export %s:=%s\n" % (i, v))
-	file.write("export VARIABLES := ");
+		if (isexported(i, 0)):
+			file.write("export %s:=%s\n" % (i, getformated(i, 0)))
+	file.write("export VARIABLES := ")
 	for i in options.keys():
-		file.write("%s " % i)
-	file.write("\n");
-#	file.write("CPUFLAGS := ");
+		if (isexported(i, 0)):
+			file.write("%s " % i)
+	file.write("\n")
+#	file.write("CPUFLAGS := ")
 #	for i in options.keys():
 #		o = options[i]
 #		file.write("-D%s=%s " % (i, o.getvalue()))
-#	file.write("\n");
-	file.close();
+#	file.write("\n")
+	file.close()
 
 
 # write the makefile
@@ -547,6 +734,7 @@ def writemakefilesettings(path):
 # first, dump all the -D stuff
 
 def writemakefile(path):
+	global root
 	makefilepath = os.path.join(path, "Makefile")
 	print "Creating", makefilepath
 	file = open(makefilepath, 'w+')
@@ -570,7 +758,7 @@ CPUFLAGS := $(foreach _var_,$(VARIABLES),$(call D_item,$(_var_)))
 
 	for i in userdefines:
 		file.write("%s\n" %i)
-	file.write("\n");
+	file.write("\n")
 
 	# print out all the object dependencies
 	file.write("\n# object dependencies (objectrules:)\n")
@@ -603,9 +791,6 @@ CPUFLAGS := $(foreach _var_,$(VARIABLES),$(call D_item,$(_var_)))
 		else:
 			file.write("CRT0_INCLUDES += $(TOP)/src/%s\n" % i)
 
-
-
-		
 	file.write("\nSOURCES=\n")
 	#for source in sources:
 		#file.write("SOURCES += %s\n" % source)
@@ -669,7 +854,7 @@ CPUFLAGS := $(foreach _var_,$(VARIABLES),$(call D_item,$(_var_)))
 	file.write("\tpython $(TOP)/util/config/NLBConfig.py %s $(TOP)\n"
 			% top_config_file)
 
-	keys = makeoptions.keys()
+	keys = root.options.keys()
 	keys.sort()
 	file.write("\necho:\n")
 	for key in keys:
@@ -684,7 +869,7 @@ CPUFLAGS := $(foreach _var_,$(VARIABLES),$(call D_item,$(_var_)))
 		file.write("\n")
 		for i in m.actions:
 			file.write("\t%s\n" % i)
-	file.close();
+	file.close()
 
 # Write out crt0_includes.h (top-level assembly language) include file.
 def writecrt0_includes(path):
@@ -695,218 +880,294 @@ def writecrt0_includes(path):
 	for i in crt0includes:
 		file.write("#include <%s>\n" % i)
 
-	file.close();
+	file.close()
 
 
 %%
 parser Config:
-    ignore:      r'\s+'
-    ignore:      "#.*?\r?\n"
-    token NUM:   r'[0-9]+'
-    token XNUM:   r'0x[0-9a-fA-F]+'
-# Why is path separate? Because paths to resources have to at least
-# have a slash, we thinks
-    token PATH:    r'[a-zA-Z0-9_.][a-zA-Z0-9/_.]+[a-zA-Z0-9_.]+'
-# Dir's on the other hand are abitrary
-# this may all be stupid.
-    token DIRPATH:    r'[a-zA-Z0-9_$()./]+'
-    token ID:    r'[a-zA-Z_.]+[a-zA-Z0-9_.]*'
-    token STR:   r'"([^\\"]+|\\.)*"'
-    token RAWTEXT: r'.*'
-    token OPTION: 'option'
-    token MAINBOARD: 'mainboard'
-    token MAINBOARDINIT: 'mainboardinit'
-    token EQ: '='
-    token END: '$|end'
-    token TARGET: 'target'
-    token OBJECT: 'object'
-    token DRIVER: 'driver'
-    token NORTHBRIDGE: 'northbridge'
-    token SOUTHBRIDGE: 'southbridge'
-    token SUPERIO: 'superio'
-    token IF: 'if'
-    token MAKERULE: 'makerule'
-    token DEP: 'dep'
-    token ACT: 'act'
-    token MAKEDEFINE: 'makedefine'
-    token ADDACTION: 'addaction'
-    token DEFAULT: 'default'
-    token INIT: 'init'
-    token REGISTER: 'register'
-    token CPU: 'cpu'
-    token ARCH: 'arch'
-    token DIR: 'dir'
-    token LDSCRIPT: 'ldscript'
-    token PAYLOAD: 'payload'
-
-    # An expression is the sum and difference of factors
-    rule expr<<V>>:   factor<<V>>         {{ n = factor }}
-                     ( "[+]" factor<<V>>  {{ n = n+factor }}
-                     |  "-"  factor<<V>>  {{ n = n-factor }}
-                     )*                   {{ return n }}
-
-    # A factor is the product and division of terms
-    rule factor<<V>>: term<<V>>           {{ v = term }}
-                     ( "[*]" term<<V>>    {{ v = v*term }}
-                     |  "/"  term<<V>>    {{ v = v/term }}
-                     |  "<<"  term<<V>>    {{ v = v << term }}
-                     |  ">=" term<<V>>    {{ v = (v < term)}}
-                     )*                   {{ return v }}
-
-    rule unop<<V>>: "!" ID                     {{ return ternary(getoption(ID), 1, 0)}}
+    ignore:			r'\s+'
+    ignore:			"#.*?\r?\n"
+
+    # less general tokens should come first, otherwise they get matched
+    # by the re's
+    token ACT:			'act'
+    token ADDACTION:		'addaction'
+    token ALWAYS:		'always'
+    token ARCH:			'arch'
+    token COMMENT:		'comment'
+    token CPU:			'cpu'
+    token DEFAULT:		'default'
+    token DEFINE:		'define'
+    token DEP:			'dep'
+    token DIR:			'dir'
+    token DRIVER:		'driver'
+    token END:			'$|end'
+    token EQ:			'='
+    token EXPORT:		'export'
+    token FORMAT:		'format'
+    token IF:			'if'
+    token INIT:			'init'
+    token LDSCRIPT:		'ldscript'
+    token LOADOPTIONS:		'loadoptions'
+    token MAINBOARD:		'mainboard'
+    token MAINBOARDINIT:	'mainboardinit'
+    token MAKEDEFINE:		'makedefine'
+    token MAKERULE:		'makerule'
+    token NEVER:		'never'
+    token NONE:			'none'
+    token NORTHBRIDGE:		'northbridge'
+    token OBJECT:		'object'
+    token OPTION:		'option'
+    token PAYLOAD:		'payload'
+    token PMC:			'pmc'
+    token REGISTER:		'register'
+    token SOUTHBRIDGE:		'southbridge'
+    token SUPERIO:		'superio'
+    token TARGET:		'target'
+    token USED:			'used'
+    token USES:			'uses'
+    token NUM:			r'[0-9]+'
+    token XNUM:			r'0x[0-9a-fA-F]+'
+    # Why is path separate? Because paths to resources have to at least
+    # have a slash, we thinks
+    token PATH:			r'[a-zA-Z0-9_.][a-zA-Z0-9/_.]+[a-zA-Z0-9_.]+'
+    # Dir's on the other hand are abitrary
+    # this may all be stupid.
+    token DIRPATH:		r'[a-zA-Z0-9_$()./]+'
+    token ID:			r'[a-zA-Z_.]+[a-zA-Z0-9_.]*'
+    token DELEXPR:		r'{([^}]+|\\.)*}'
+    token STR:			r'"([^\\"]+|\\.)*"'
+    token RAWTEXT:		r'.*'
+
+    rule expr<<V>>:	logical<<V>>		{{ l = logical }}
+			( "&&" logical<<V>>	{{ l = l and logical }}
+			| "||"  logical<<V>>	{{ l = l or logical }}
+			)*			{{ return l }}
+
+    rule logical<<V>>:	factor<<V>>		{{ n = factor }}
+			( "[+]" factor<<V>>	{{ n = n+factor }}
+			| "-"  factor<<V>>	{{ n = n-factor }}
+			)*			{{ return n }}
+
+    rule factor<<V>>:	term<<V>>		{{ v = term }}
+			( "[*]" term<<V>>	{{ v = v*term }}
+			| "/"  term<<V>>	{{ v = v/term }}
+			| "<<"  term<<V>>	{{ v = v << term }}
+			| ">=" term<<V>>	{{ v = (v < term)}}
+			)*			{{ return v }}
+
+    rule unop<<V>>:	"!" ID			{{ return ternary(getoption(ID, curpart), 1, 0)}}
+
     # A term is a number, variable, or an expression surrounded by parentheses
-    rule term<<V>>:
-                 NUM                      {{ return atoi(NUM) }}
-               | XNUM                      {{ return tohex(XNUM) }}
-               | ID                      {{ return tohex(getoption(ID)) }}
-               | unop<<V>>                 {{ return unop }}
-               | "\\(" expr<<V>> "\\)"         {{ return expr }}
-
-    rule option<<C>>: OPTION ID EQ 
-				(
-			STR {{ if (C): setoption(ID, dequote(STR)) }} 
-			|	term<<[]>> {{ if (C): setoption(ID, term) }}
-			)
-    rule default<<C>>: DEFAULT ID EQ RAWTEXT {{ if (C): setdefault(ID, RAWTEXT) }}
-
-    rule partend<<C>>: partstmts<<C>> END  
-    rule mainboard: MAINBOARD PATH {{mainboard(PATH) }} 
-				partend<<1>>
+    rule term<<V>>:	NUM			{{ return atoi(NUM) }}
+		|	XNUM			{{ return tohex(XNUM) }}
+		|	ID			{{ return tohex(getoption(ID, curpart)) }}
+		|	unop<<V>>		{{ return unop }}
+		|	"\\(" expr<<V>> "\\)"	{{ return expr }}
+
+    rule partend<<C>>:	partstmts<<C>> END  
+
+    rule mainboard:	MAINBOARD PATH		{{ mainboard(PATH) }}
+			partend<<1>>
 			
-    rule northbridge<<C>>: NORTHBRIDGE PATH 
-			{{if (C): part('northbridge', PATH, 'Config.lb')}} partend<<C>>
-    rule superio<<C>>: SUPERIO PATH 
-			{{if (C): part('superio', PATH, 'Config.lb')}} partend<<C>>
-    rule cpu<<C>>: CPU ID 
-			{{if (C): part('cpu', ID, 'Config.lb')}} partend<<C>>
-    rule arch<<C>>: ARCH ID 
-			{{if (C): set_arch(ID) }} partend<<C>>
-    rule southbridge<<C>>: SOUTHBRIDGE PATH 
-			{{if (C): part('southbridge', PATH, 'Config.lb')}} partend<<C>>
+    rule northbridge<<C>>:
+			NORTHBRIDGE PATH	{{ if (C): part('northbridge', PATH, 'Config.lb') }}
+			partend<<C>>
+
+    rule superio<<C>>:	SUPERIO PATH		{{ if (C): part('superio', PATH, 'Config.lb') }}
+			partend<<C>>
+
+    rule cpu<<C>>:	CPU ID			{{ if (C): part('cpu', ID, 'Config.lb') }}
+			partend<<C>>
+
+    rule pmc<<C>>:	PMC PATH		{{ if (C): part('pmc', PATH, 'Config.lb') }}
+			partend<<C>>
+
+    rule arch<<C>>:	ARCH ID			{{ if (C): set_arch(ID) }}
+			partend<<C>>
+
+    rule southbridge<<C>>:
+			SOUTHBRIDGE PATH	{{ if (C): part('southbridge', PATH, 'Config.lb')}}
+			partend<<C>>
 
     rule mainboardinit<<C>>: 
-		 MAINBOARDINIT DIRPATH {{ if (C): addcrt0include(DIRPATH)}}
+			MAINBOARDINIT DIRPATH	{{ if (C): addcrt0include(DIRPATH)}}
+
+    rule object<<C>>:	OBJECT DIRPATH		{{ if (C): addobject(DIRPATH)}}
 
-    rule object<<C>>: OBJECT DIRPATH {{if (C): addobject(DIRPATH)}}
-    rule driver<<C>>: DRIVER DIRPATH {{if (C): adddriver(DIRPATH)}}
-    rule dir<<C>>:	DIR DIRPATH  {{if (C): dodir(DIRPATH, 'Config.lb') }}
+    rule driver<<C>>:	DRIVER DIRPATH		{{ if (C): adddriver(DIRPATH)}}
+
+    rule dir<<C>>:	DIR DIRPATH 		{{ if (C): dodir(DIRPATH, 'Config.lb') }}
+
+    rule ldscript<<C>>:	LDSCRIPT DIRPATH	{{ if (C): addldscript(DIRPATH) }}
+
+    rule payload<<C>>:	PAYLOAD DIRPATH		{{ if (C): payload(DIRPATH) }}
 
-    rule ldscript<<C>>: LDSCRIPT DIRPATH {{if (C): addldscript(DIRPATH) }}
-    rule payload<<C>>: PAYLOAD DIRPATH {{if (C): payload(DIRPATH) }}
 # if is a bad id ....
-    rule iif<<C>>:
 # needs to be C and ID, but nested if's are, we hope, not going to 
 # happen. IF so, possibly ID && C could be used.
-		IF ID {{ c = tohex(getoption(ID)); print "IF %d\n" % c }} (stmt<<c>>)* END
+    rule iif<<C>>:	IF ID			{{ c = tohex(getoption(ID, curpart)) }} 
+			(stmt<<c>>)* END
 
-    rule depsacts<<ID, C>>: (
-			DEP  STR {{ if (C): adddep(ID, STR) }}
-			| ACT STR {{ if (C): addaction(ID, STR) }}
+    rule depsacts<<ID, C>>:
+			( DEP STR		{{ if (C): adddep(ID, STR) }}
+			| ACT STR		{{ if (C): addaction(ID, STR) }}
 			)*
-    rule makerule<<C>>: MAKERULE DIRPATH {{ if (C): addrule(DIRPATH) }} 
+
+    rule makerule<<C>>:	MAKERULE DIRPATH	{{ if (C): addrule(DIRPATH) }} 
 			depsacts<<DIRPATH, C>> 
-    rule makedefine<<C>>: MAKEDEFINE RAWTEXT
-			 {{ if (C): adduserdefine(RAWTEXT) }}
-    rule addaction<<C>>: ADDACTION ID STR
-			 {{ if (C): addaction(ID, STR) }}
-    rule init<<C>>:   INIT  STR  {{ if (C): curpart.addinit(STR) }}
-    rule register<<C>>:   REGISTER  STR  {{ if (C): curpart.addregister(STR) }}
+
+    rule makedefine<<C>>:
+			MAKEDEFINE RAWTEXT	{{ if (C): adduserdefine(RAWTEXT) }}
+
+    rule addaction<<C>>:
+			ADDACTION ID STR	{{ if (C): addaction(ID, STR) }}
+
+    rule init<<C>>:	INIT STR		{{ if (C): curpart.addinit(STR) }}
+
+    rule register<<C>>:	REGISTER STR		{{ if (C): curpart.addregister(STR) }}
 
 # to make if work without 2 passses, we use an old hack from SIMD, the 
 # context bit. If the bit is 1, then ops get done, otherwise
 # ops don't get done. From the top level, context is always
 # 1. In an if, context depends on eval of the if condition
-    rule stmt<<C>>:   
-		  option<<C>>		  {{ return option }}
-		| default<<C>>	  {{ return default }}
-        	| cpu<<C>>          {{ return cpu}}
-        	| arch<<C>>          {{ return arch}}
-		| northbridge<<C>>	  {{ return northbridge }}
-		| southbridge<<C>>	  {{ return southbridge }}
-		| superio<<C>>	  {{ return superio }}
-		| object<<C>>	  {{ return object }}
-		| driver<<C>>	  {{ return driver }}
-		| mainboardinit<<C>>   {{ return mainboardinit }}
-		| makerule<<C>> 	  {{ return makerule }}
-		| makedefine<<C>> 	  {{ return makedefine }}
-		| addaction<<C>> 	  {{ return addaction }}
-		| init<<C>> 		  {{ return init }}
-		| register<<C>> 		  {{ return register}}
-		| iif<<C>>	  {{ return iif }}
-		| dir<<C>>		{{ return dir}}
-		| ldscript<<C>>		{{ return ldscript}}
-		| payload<<C>>		{{ return payload}}
-
-    rule stmts<<C>>: (stmt<<C>>)* 		{{  }}
-
-    rule partstmts<<C>>: (stmt<<C>>)* 		{{  partpop()}}
+    rule stmt<<C>>:	cpu<<C>>		{{ return cpu}}
+		|	pmc<<C>>		{{ return pmc}}
+		|	arch<<C>>		{{ return arch}}
+		|	northbridge<<C>>	{{ return northbridge }}
+		|	southbridge<<C>>	{{ return southbridge }}
+		|	superio<<C>>		{{ return superio }}
+		|	object<<C>>		{{ return object }}
+		|	driver<<C>>		{{ return driver }}
+		|	mainboardinit<<C>>	{{ return mainboardinit }}
+		|	makerule<<C>>		{{ return makerule }}
+		|	makedefine<<C>> 	{{ return makedefine }}
+		|	addaction<<C>>		{{ return addaction }}
+		|	init<<C>>	 	{{ return init }}
+		|	register<<C>> 		{{ return register}}
+		|	iif<<C>>		{{ return iif }}
+		|	dir<<C>>		{{ return dir}}
+		|	ldscript<<C>>		{{ return ldscript}}
+		|	payload<<C>>		{{ return payload}}
+
+    rule stmts<<C>>:	(stmt<<C>>)*	 	{{ }}
+
+    rule partstmts<<C>>:
+			(uses<<C>>)*
+			(stmt<<C>>)*	 	{{  partpop()}}
+
 # need this to get from python to the rules, I think.
+    rule pstmts:	(uses<<1>>)* stmts<<1>>	{{ return 1 }}
+
+    rule usesid<<C>>:	ID			{{ if (C): usesoption(ID) }}
+
+    rule uses<<C>>:	USES (usesid<<C>>)+
+
+    rule value:		STR			{{ return dequote(STR) }} 
+		| 	term<<[]>>		{{ return term }}
+		|	DELEXPR			{{ return DELEXPR }}
+
+    rule option:	OPTION ID EQ value	{{ setoptionstmt(ID, value) }}
+
+    rule board:		LOADOPTIONS		{{ loadoptions() }}
+	    		TARGET DIRPATH		{{ target(DIRPATH) }}
+			(uses<<1>>)*
+			(option)*
+			mainboard		{{ return 1 }}
+
+    rule defstmts<<ID>>:			{{ d = 0 }}
+			( DEFAULT
+			  ( value		{{ setdefault(ID, value) }}
+			  | NONE		{{ setnodefault(ID) }}
+			  )			{{ d |= 1 }}
+			| FORMAT STR		{{ setformat(ID, dequote(STR)) }}
+			| EXPORT 
+			  ( ALWAYS		{{ setexported(ID) }}
+			  | USED		{{ setexport(ID) }}
+			  | NEVER		{{ setnoexport(ID) }}
+			  )			{{ d |= 2 }}
+			| COMMENT STR 		{{ setcomment(ID, dequote(STR)); d |= 4 }}
+			)+			{{ return d }}
+		
+    rule define:	DEFINE ID 		{{ newoption(ID) }}
+			defstmts<<ID>> END	{{ validdef(ID, defstmts) }}
 
-    rule pstmts: stmts<<1>> 			{{ }}
-    rule target: TARGET DIRPATH            {{target(DIRPATH)}}
-    rule board: target mainboard   {{ }}
+    rule options:	(define)* END		{{ return 1 }}
 %%
 
 def dumptree(part, lvl):
-	print "DUMPTREE ME is"
+	if (debug):
+		print "DUMPTREE ME is"
 	part.dumpme(lvl)
 	# dump the siblings -- actually are there any? not sure
 	# dump the kids
-	print "DUMPTREE KIDS are"
+	if (debug):
+		print "DUMPTREE KIDS are"
 	for kid in part.children:
 		dumptree(kid, lvl+1)
-	print "DONE DUMPTREE"
+	if (debug):
+		print "DONE DUMPTREE"
 
 def gencode(part):
-	print "GENCODE ME is"
-	part.gencode()
+	if (debug):
+		print "GENCODE ME is"
+	if (debug):
+		part.gencode()
 	# dump the siblings -- actually are there any? not sure
 	# dump the kids
-	print "GENCODE KIDS are"
+	if (debug):
+		print "GENCODE KIDS are"
 	for kid in part.children:
 		gencode(kid)
-	print "DONE GENCODE"
+	if (debug):
+		print "DONE GENCODE"
 	
 
 def doconfigfile(path, file):
 	if (debug):
 		print "DOCONFIGFILE", path, " ", file
 	filename = os.path.join(path, file)
-	loc.push_file(filename);
-	parse('pstmts', open(filename, 'r').read())
+	loc.push_file(filename)
+	if (not parse('pstmts', open(filename, 'r').read())):
+		fatal("Error: Could not parse file")
 
 if __name__=='__main__':
-    from sys import argv
-    if (len(argv) < 3):
-	print 'Args: <file> <path to linuxbios>'
-
-    top_config_file = os.path.abspath(sys.argv[1])
-
-    treetop = os.path.abspath(sys.argv[2])
-
-    # Set the default locations for config files.
-    makebase = os.path.join(treetop, "util/config/make.base")
-    crt0base = os.path.join(treetop, "arch/i386/config/crt0.base")
-    doxyscriptbase = os.path.join(treetop, "src/config/doxyscript.base")
-    
-    # Now read in the customizing script...
-    loc.push_file(argv[1]);
-    parse('board', open(argv[1], 'r').read())
-    dumptree(curpart, 0)
-    gencode(curpart)
-    for i in options.keys():
-	o = options[i]
-	print "key %s @%s: val %s" % (i, o.where(), o.getvalue())
-    # crt0 includes
-    for i in crt0includes:
-    	print "crt0include file %s \n" % (i)
-    for i in driverrules.keys():
-    	print "driver file %s \n" % (i)
-    for i in ldscripts:
-	print "ldscript file %s\n" % (i)
-    for i in makebaserules.keys():
-	m = makebaserules[i]
-	print " makerule %s dep %s act %s\n" % (i, m.dependency, m.actions)
-    writemakefilesettings(target_dir)
-    writecrt0_includes(target_dir)
-    writemakefile(target_dir)
+	from sys import argv
+	if (len(argv) < 3):
+		print 'Args: <file> <path to linuxbios>'
+		sys.exit(1)
+
+	top_config_file = os.path.abspath(sys.argv[1])
+
+	treetop = os.path.abspath(sys.argv[2])
+
+	# Now read in the customizing script...
+	loc.push_file(argv[1])
+	if (not parse('board', open(argv[1], 'r').read())):
+		fatal("Error: Could not parse file")
+
+	if (debug):
+		print "DEVICE TREE:"
+		dumptree(root, 0)
+
+	gencode(root)
+
+	for i in options.keys():
+		if (isexported(i, 0) and not isset(i, 0)):
+			print "WARNING: Option %s using default value %s" % (i, getformated(i, 0))
+
+	# crt0 includes
+	if (debug):
+		for i in crt0includes:
+			print "crt0include file %s" % (i)
+		for i in driverrules.keys():
+			print "driver file %s" % (i)
+		for i in ldscripts:
+			print "ldscript file %s" % (i)
+		for i in makebaserules.keys():
+			m = makebaserules[i]
+			print " makerule %s dep %s act %s" % (i, m.dependency, m.actions)
+
+	writemakefilesettings(target_dir)
+	writecrt0_includes(target_dir)
+	writemakefile(target_dir)