Simplifying template arguments

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

diff --git a/examples/simpleExample.kll b/examples/simpleExample.kll
index a31044ef4900b68297079f6ea6af38ffb506fda8..560432e2553ac7a433b3d95b90520d981e0f4fbb 100644 (file)
--- a/examples/simpleExample.kll
+++ b/examples/simpleExample.kll
@@ -1,7 +1,8 @@
-Name = colemak;
-Author = "HaaTa (Jacob Alexander) 2014";
-KLL = 0.2a;
+Name = "Simple Example";
+Author = "HaaTa (Jacob Alexander) 2014-2015";
+KLL = 0.3a;
 
+usbKeyOut => Output_usbCodeSend_capability( usbCode : 1 );
 #S0x40 : U0x43;
 S0x40 : U"Backspace";
 

diff --git a/kll.py b/kll.py
index cc33b578a872cbf1dc92ff36a2ecb46015dc40bf..eab30981aa6d4abdeeb318dd80074f26bf669482 100755 (executable)
--- a/kll.py
+++ b/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" )
-       pArgs.add_argument( '--defines-template', type=str, default="templates/kiibohdDefs.h",
-               help="Specify template used to generate kll_defs.h.\n"
-               "Default: templates/kiibohdDefs.h" )
-       pArgs.add_argument( '-o', '--output', type=str, default="generatedKeymap.h",
+               "Default: templates/kiibohdKeymap.h templates/kiibohdDefs.h" )
+       pArgs.add_argument( '-o', '--outputs', type=str, nargs='+',
+               default=["generatedKeymap.h", "kll_defs.h"],
                help="Specify output file. Writes to current working directory by default.\n"
-               "Default: generatedKeymap.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" )
+               "Default: generatedKeymap.h 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 )

diff --git a/kll_lib/backends.py b/kll_lib/backends.py
index 38ce9168b28a317298a9c3de8cd72b2cdb41ec90..09d430da69769b9383aa1389483ab03d0dff210f 100644 (file)
--- a/kll_lib/backends.py
+++ b/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 ):
-               # Does template exist?
-               if not os.path.isfile( templatePath ):
-                       print ( "{0} '{1}' does not exist...".format( ERROR, templatePath ) )
-                       sys.exit( 1 )
-
-               self.definesTemplatePath = definesTemplatePath
-               self.templatePath = templatePath
+       def __init__( self, templatePaths=[] ):
+               self.templatePaths = templatePaths
                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 line in openFile:
-                               match = re.findall( '<\|([^|>]+)\|>', line )
-                               for item in match:
-                                       self.tagList.append( item )
-               with open( definesTemplatePath, 'r' ) as openFile:
-                       for line in openFile:
-                               match = re.findall( '<\|([^|>]+)\|>', line )
-                               for item in match:
-                                       self.tagList.append( item )
+               for templatePath in templatePaths:
+                       # Does template exist?
+                       if not os.path.isfile( templatePath ):
+                               print ( "{0} '{1}' does not exist...".format( ERROR, templatePath ) )
+                               sys.exit( 1 )
+
+                       # Generate list of fill tags
+                       with open( templatePath, 'r' ) as openFile:
+                               for line in openFile:
+                                       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 ):
-               # Process each line of the template, outputting to the target path
-               with open( outputPath, 'w' ) as outputFile:
-                       with open( self.templatePath, '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 )
-
-               # 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 )
+       def generate( self, outputPaths ):
+               for templatePath, outputPath in zip( self.templatePaths, outputPaths ):
+                       # Process each line of the template, outputting to the target path
+                       with open( outputPath, 'w' ) as outputFile:
+                               with open( templatePath, '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 )