Simplifying template arguments

- Command Line arguments have slightly changed (will require controller git update)
- In preparation for JSON I/O

examples/simpleExample.kll

@@ -1,7 +1,8 @@
-Name = colemak;
+Name = "Simple Example";
-Author = "HaaTa (Jacob Alexander) 2014";
+Author = "HaaTa (Jacob Alexander) 2014-2015";
-KLL = 0.2a;
+KLL = 0.3a;
 
+usbKeyOut => Output_usbCodeSend_capability( usbCode : 1 );
 #S0x40 : U0x43;
 S0x40 : U"Backspace";
 

kll.py

@@ -90,18 +90,14 @@ def processCommandLineArgs():
 		help="Specify .kll files to generate partial map, multiple files per flag.\n"
 		"Each -p defines another partial map.\n"
 		"Base .kll files (that define the scan code maps) must be defined for each partial map." )
-	pArgs.add_argument( '-t', '--template', type=str, default="templates/kiibohdKeymap.h",
+	pArgs.add_argument( '-t', '--templates', type=str, nargs='+',
+		default=["templates/kiibohdKeymap.h", "templates/kiibohdDefs.h"],
 		help="Specify template used to generate the keymap.\n"
-		"Default: templates/kiibohdKeymap.h" )
+		"Default: templates/kiibohdKeymap.h templates/kiibohdDefs.h" )
-	pArgs.add_argument( '--defines-template', type=str, default="templates/kiibohdDefs.h",
+	pArgs.add_argument( '-o', '--outputs', type=str, nargs='+',
-		help="Specify template used to generate kll_defs.h.\n"
+		default=["generatedKeymap.h", "kll_defs.h"],
-		"Default: templates/kiibohdDefs.h" )
-	pArgs.add_argument( '-o', '--output', type=str, default="generatedKeymap.h",
 		help="Specify output file. Writes to current working directory by default.\n"
-		"Default: generatedKeymap.h" )
+		"Default: generatedKeymap.h kll_defs.h" )
-	pArgs.add_argument( '--defines-output', type=str, default="kll_defs.h",
-		help="Specify output path for kll_defs.h. Writes to current working directory by default.\n"
-		"Default: kll_defs.h" )
 	pArgs.add_argument( '-h', '--help', action="help",
 		help="This message." )
 
@@ -128,7 +124,7 @@ def processCommandLineArgs():
 		for filename in partial:
 			checkFileExists( filename )
 
-	return (baseFiles, defaultFiles, partialFileSets, args.backend, args.template, args.defines_template, args.output, args.defines_output)
+	return (baseFiles, defaultFiles, partialFileSets, args.backend, args.templates, args.outputs)
 
 
 
@@ -588,7 +584,7 @@ def gitRevision( kllPath ):
 ### Main Entry Point ###
 
 if __name__ == '__main__':
-	(baseFiles, defaultFiles, partialFileSets, backend_name, template, defines_template, output, defines_output) = processCommandLineArgs()
+	(baseFiles, defaultFiles, partialFileSets, backend_name, templates, outputs) = processCommandLineArgs()
 
 	# Look up git information on the compiler
 	gitRev, gitChanges = gitRevision( os.path.dirname( os.path.realpath( __file__ ) ) )
@@ -596,7 +592,7 @@ if __name__ == '__main__':
 	# Load backend module
 	global backend
 	backend_import = importlib.import_module( "backends.{0}".format( backend_name ) )
-	backend = backend_import.Backend( template, defines_template )
+	backend = backend_import.Backend( templates )
 
 	# Process base layout files
 	for filename in baseFiles:
@@ -641,7 +637,7 @@ if __name__ == '__main__':
 	)
 
 	# Generate output file using template and backend
-	backend.generate( output, defines_output )
+	backend.generate( outputs )
 
 	# Successful Execution
 	sys.exit( 0 )

kll_lib/backends.py

@@ -38,28 +38,24 @@ WARNING = '\033[5;1;33mWARNING\033[0m:'
 class BackendBase:
 	# Initializes backend
 	# Looks for template file and builds list of fill tags
-	def __init__( self, templatePath, definesTemplatePath ):
+	def __init__( self, templatePaths=[] ):
-		# Does template exist?
+		self.templatePaths = templatePaths
-		if not os.path.isfile( templatePath ):
-			print ( "{0} '{1}' does not exist...".format( ERROR, templatePath ) )
-			sys.exit( 1 )
-
-		self.definesTemplatePath = definesTemplatePath
-		self.templatePath = templatePath
 		self.fill_dict = dict()
 
-		# Generate list of fill tags
+		# Process each template and add to tagList
 		self.tagList = []
-		with open( templatePath, 'r' ) as openFile:
+		for templatePath in templatePaths:
-			for line in openFile:
+			# Does template exist?
-				match = re.findall( '<\|([^|>]+)\|>', line )
+			if not os.path.isfile( templatePath ):
-				for item in match:
+				print ( "{0} '{1}' does not exist...".format( ERROR, templatePath ) )
-					self.tagList.append( item )
+				sys.exit( 1 )
-		with open( definesTemplatePath, 'r' ) as openFile:
+
-			for line in openFile:
+			# Generate list of fill tags
-				match = re.findall( '<\|([^|>]+)\|>', line )
+			with open( templatePath, 'r' ) as openFile:
-				for item in match:
+				for line in openFile:
-					self.tagList.append( item )
+					match = re.findall( '<\|([^|>]+)\|>', line )
+					for item in match:
+						self.tagList.append( item )
 
 
 	# USB Code Capability Name
@@ -69,44 +65,29 @@ class BackendBase:
 
 
 	# Processes content for fill tags and does any needed dataset calculations
+	# XXX Make sure to override
 	def process( self, capabilities, macros, variables, gitRev, gitChanges ):
 		print ( "{0} BackendBase 'process' function must be overridden".format( ERROR ) )
 		sys.exit( 2 )
 
 
 	# Generates the output keymap with fill tags filled
-	def generate( self, outputPath, definesOutputPath ):
+	def generate( self, outputPaths ):
-		# Process each line of the template, outputting to the target path
+		for templatePath, outputPath in zip( self.templatePaths, outputPaths ):
-		with open( outputPath, 'w' ) as outputFile:
+			# Process each line of the template, outputting to the target path
-			with open( self.templatePath, 'r' ) as templateFile:
+			with open( outputPath, 'w' ) as outputFile:
-				for line in templateFile:
+				with open( templatePath, 'r' ) as templateFile:
-					# TODO Support multiple replacements per line
+					for line in templateFile:
-					# TODO Support replacement with other text inline
+						# TODO Support multiple replacements per line
-					match = re.findall( '<\|([^|>]+)\|>', line )
+						# TODO Support replacement with other text inline
+						match = re.findall( '<\|([^|>]+)\|>', line )
 
-					# If match, replace with processed variable
+						# If match, replace with processed variable
-					if match:
+						if match:
-						outputFile.write( self.fill_dict[ match[ 0 ] ] )
+							outputFile.write( self.fill_dict[ match[ 0 ] ] )
-						outputFile.write("\n")
+							outputFile.write("\n")
 
-					# Otherwise, just append template to output file
+						# Otherwise, just append template to output file
-					else:
+						else:
-						outputFile.write( line )
+							outputFile.write( line )
-
-		# Process each line of the defines template, outputting to the target path
-		with open( definesOutputPath, 'w' ) as outputFile:
-			with open( self.definesTemplatePath, 'r' ) as templateFile:
-				for line in templateFile:
-					# TODO Support multiple replacements per line
-					# TODO Support replacement with other text inline
-					match = re.findall( '<\|([^|>]+)\|>', line )
-
-					# If match, replace with processed variable
-					if match:
-						outputFile.write( self.fill_dict[ match[ 0 ] ] )
-						outputFile.write("\n")
-
-					# Otherwise, just append template to output file
-					else:
-						outputFile.write( line )