Ticket #12: cmdLnArgs1.patch

Source/Compiler.cobra

@@ -393 +393 @@
                 assert modules.count
                 _modules.addRange(modules)
             return modules
-
+            
+    # default invocation of runProcess - no explicit exeName and no argList
     def runProcess as Process
+        return .runProcess(nil, nil)
+    
+    def runProcess(exeName as String?, argList as IList<of String>?) as Process     
         """
+        Run a Process passing optional explicit exeName and argList
         Returns a new Process with startInfo.fileName and p.startInfo.arguments set appropriately
-        for the produced executable and the current options.
+        for the produced executable and the current options and any provided arglist.
         """
-        # TODO: support args to the program with a - or -- separator
         p = Process()
+        if exeName
+            baseExeFileName = exeName
+            fullExeFileName = exeName 
+        else
+            baseExeFileName = .baseExeFileName
+            fullExeFileName = .fullExeFileName
         branch .platform
             on PlatformEnum.Microsoft
-                p.startInfo.fileName = .baseExeFileName
+                p.startInfo.fileName = baseExeFileName
             on PlatformEnum.Novell
+                # fixup fullExeFileName
+                if not '.' in fullExeFileName 
+                    fullExeFileName += '.exe'                   
                 p.startInfo.fileName = 'mono'
                 args = ''
                 # mono also needs --debug when running
                 if .options.getDefault('debug', '') not in ['', '-']
                     args += '--debug '
-                args += '"[.fullExeFileName]"'
+                args += '"[fullExeFileName]"'
                 p.startInfo.arguments = args
             else
                 throw FallThroughException(.platform)
+                
+        if argList
+            args = p.startInfo.arguments ? ''
+            args += Utils.join(' ', argList)
+            p.startInfo.arguments = args
+        
         return p
 
     ##

Source/CommandLine.cobra

@@ -201 +201 @@
         },
         {
             'name': 'reference',
-            'synonyms': ['r'],
+            'synonyms': ['r'], # TODO: lose 'r' ->'ref'.
             'isAccumulator': true,
             'description': 'Add a DLL reference.',
             'args': 'Some.dll',
@@ -220 +220 @@
 #           'args': ':Qualified.Type.Name',
 #       },
         {
-            'name': 'run',
+            'name': 'run',  # TODO: add Synonym 'r' after change 'reference' switch
             'description': 'Runs the Cobra program. This is the default behavior if specify any Cobra source files.',
             'type': 'main',
         },
+
+        {    # TODO: Merge this into the above (-run)
+            'name': 'exec-args',  # TODO: -> 'run' after add 'r' synonym to 'run'.
+            'synonyms': ['X'],
+            'description': 'Remaining args are filename to execute and args to pass to it.',
+            'eg':          '-X echo arg1 arg2 argThree',
+            'type': 'exe-args-list',  #'main'
+        },
+        
+        {       
+            'name': 'run-args',
+            'synonyms': ['-'],  #'--'
+            'description': 'Remaining args are to be passed to executable.',
+            'eg':          '-- arg1 arg2 argThree',
+            'type': 'args-list',
+        },
+            
         {
             'name': 'sharp-compiler',
             'description': 'Specify the path to the backend C# compiler.',
@@ -287 +304 @@
 
     var _options = Options()
     var _pathList as List<of String>?
+    var _runArgs  as IList<of String>?  # nil or args set for running exe
+    var _exeFileName as String?         # Name specified for exe to run
     var _htmlWriter as HtmlWriter?
 
     var _compiler as Compiler?
@@ -389 +408 @@
         if _htmlWriter
             _htmlWriter.writeHtml('</body></html>[_htmlWriter.newLine]')
 
-    def isOptionSpecRestrictionViolated(optionSpec as Dictionary<of String, Object>) as bool
-        """
-        Returns true if the option spec has a 'restriction' key and the check against that restriction is true.
-        """
-        if optionSpec.containsKey('restriction')
-            branch optionSpec['restriction'] to String
-                on 'mono-only'
-                    return not CobraCore.isRunningOnMono
-        return false
-
     def parseArgs(args as IList<of String>, options as out Options?, paths as out List<of String>?)
         """
         Parse command line arguments.
@@ -407 +416 @@
         ensure
             options
             paths
-        body
+        body    
             optionPrefix = '-'
-            valuePrefix = c':'
             if not args.count
                 options = Options()
                 options.add('help', true)
@@ -421 +429 @@
             synToName = Dictionary<of String, String>()
                 # ^ maps synonyms to their full names
             synList = List<of String>()
-            for d in _optionSpecs
-                if .isOptionSpecRestrictionViolated(d)
-                    continue
-                specDict[d['name'] to String] = d
-                if d.containsKey('synonyms')
-                    syns = d['synonyms'] to System.Collections.IList
-                    for syn as String in syns
-                        assert not specDict.containsKey(syn)
-                        specDict[syn] = d
-                        synToName[syn] = d['name'] to String
-                        synList.add(syn)
-                if not d.containsKey('type')
-                    d.add('type', 'string')
+            .initSynonyms( specDict, synToName, synList)
 
             # set up initial valueDict
             valueDict = Dictionary<of String, Object>()
             if Utils.isDevMachine
                 valueDict['reveal-internal-exceptions'] = true  # this is a specially computed default, but can still be overridden on the command line
 
+            value = 'no-value' to dynamic
+            valueStr = 'no-value'
             fileList = List<of String>()
-            value = 'no-value' to dynamic
             mainOptions = List<of String>()
             didSpecify = Dictionary<of String, bool>()  # CC: could just be a Set
+            argn=0
             for arg in args
+                argn += 1   # next arg after current
                 if arg.trim.length == 0
                     continue
-                if arg.startsWith(optionPrefix)
-                    isOption = true
-                    while arg.startsWith(optionPrefix)
-                        arg = arg[1:]
-                else
-                    isOption = false
+                    
+                isOption = arg.startsWith(optionPrefix)
                 if isOption
-                    parts = arg.split(@[valuePrefix], 2)
-                    if parts.length == 1
-                        name = parts[0]
-                        if name.endsWith('+')
-                            name = name[:-1]
-                            valueStr = 'on'
-                        else if name.endsWith('-')
-                            name = name[:-1]
-                            valueStr = 'off'
-                        else
-                            valueStr = 'on'
-                    else
-                        assert parts.length == 2
-                        name = parts[0]
-                        valueStr = parts[1]
-                    assert name.length, parts
-                    name = Utils.getSS(synToName to passthrough, name, name) to !
-                    if not specDict.containsKey(name)
-                        msg = 'No such option "[name]".'
-                        if name.contains('=')
-                            msg += ' If you meant to specify an option value, use colon (:) instead of equals (=).'
-                        .error(msg)
+                    name = .getOptionParts(arg, optionPrefix, synToName, specDict, out valueStr)
                     spec = specDict[name]
-                    if Utils.getSB(spec to passthrough, 'isAccumulator', false)
-                        # accumulators are always treated as strings. TODO: assert that
-                        if valueDict.containsKey(name)
-                            (valueDict[name] to System.Collections.IList).add(valueStr to passthrough)
-                        else
-                            valueDict[name] = [valueStr]
-                            didSpecify[name] = true
-                    else
-                        cannotProcess = false
-                        if name=='debug'
-                            # special case
-                            if valueStr=='pdbonly' or valueStr=='full'
-                                value = valueStr
-                            else
-                                try
-                                    value = .boolForString(valueStr)
-                                catch FormatException
-                                    cannotProcess = true
-                                success
-                                    value = if(value, '+', '-')
-                        else
-                            if spec['type'] == 'main'
-                                mainOptions.add(name)
-                                value = true
-                            else
-                                possible = .interpretValue(valueStr, spec)
-                                if possible is not nil
-                                    value = possible
-                                else
-                                    cannotProcess = true
-                        if cannotProcess
-                            .error('Cannot process value "[valueStr]" for option "[name]".')
-                        valueDict[name] = value
-                        didSpecify[name] = true
+
+                    if .isAccumulatorOption(spec)
+                        .accumulateOptionValue(name, valueStr, valueDict, didSpecify)
+                        continue
+                        
+                    cannotProcess = argsDone = false
+                    value = .processToValue(name, valueStr, spec, mainOptions, args, argn, out cannotProcess, out argsDone )
+                    if argsDone
+                        break   # slurpt up rest of args
+                    if cannotProcess
+                        .error('Cannot process value "[valueStr]" for option "[name]".')
+                    valueDict[name] = value
+                    didSpecify[name] = true
                 else # not isOption
-                    if File.exists(arg)
-                        fileList.add(arg)
-                    else if File.exists(arg+'.cobra')
-                        fileList.add(arg+'.cobra')
-                    else if Directory.exists(arg)
-                        fileList.add(arg)
-                    else
-                        msg = 'Cannot find "[arg]" as a file.'
-                        if arg.startsWith('/')
-                            msg += ' If you meant to specify an option, use dash (-) instead of slash (/).'
-                        .error(msg)
+                    if arg.startsWith('/')
+                        errHint = ' If you meant to specify an option, use dash (-) instead of slash (/).'
+                    .processAsFile(arg, fileList, errHint)
 
-            # handle synonyms
-            for syn in synList
-                if valueDict.containsKey(syn)
-                    valueDict[synToName[syn]] = valueDict[syn]
-                    valueDict.remove(syn)
+            .handleSynonyms(synList, synToName, valueDict)          
+            .addInDefaults(valueDict)       
 
-            # add in defaults
-            for d in _optionSpecs
-                defaultName = d['name'] to String
-                if not valueDict.containsKey(defaultName) and d.containsKey('default')
-                    defaultValue = .interpretValue(d['default'] to String, d) to !
-                    if .verbosity
-                        print 'Setting option "[defaultName]" to default value [defaultValue].'
-                    valueDict[defaultName] = defaultValue
-
             # TODO: make the option names case-insensitive
 
             # check for more than one main option
             if mainOptions.count > 1
                 .error('Cannot have these main options at the same time: [Utils.join(", ", mainOptions)]')
 
-            # unpack certain options into specific class fields
-            if valueDict.containsKey('verbosity')
-                _verbosity = valueDict['verbosity'] to int
-            if not valueDict.containsKey('timeit') and valueDict.containsKey('testify')
-                valueDict['timeit'] = true
-            if valueDict.containsKey('timeit')
-                CobraMain.willTimeIt = valueDict['timeit'] to bool
-            if valueDict.containsKey('files')
-                for fileName as String in valueDict['files'] to System.Collections.IList
-                    try
-                        for line in File.readAllLines(fileName)
-                            line = line.trim
-                            if line.length==0 or line.startsWith('#')
-                                continue
-                            # TODO: dup'ed above
-                            arg = line
-                            if File.exists(arg)
-                                fileList.add(arg)
-                            else if File.exists(arg+'.cobra')
-                                fileList.add(arg+'.cobra')
-                            else if Directory.exists(arg)
-                                fileList.add(arg)
-                            else
-                                msg = 'Cannot find "[arg]" as a file.'
-                                #if arg.startsWith('/')
-                                #   msg += ' If you meant to specify an option, use dash (-) instead of slash (/).'
-                                .error(msg)
-                            # end dup
-                    catch IOException
-                        .error('Cannot open file "[fileName]".')
+            .unpackOptions(valueDict, fileList) 
 
             # set the out parameters
             options = Options(valueDict)
@@ -584 +488 @@
 
             .computeArgImplications(options to !)
 
+        
+    def getOptionParts(arg as String, _
+                optionPrefix as String, _
+                synToName as Dictionary<of String, String>, _
+                specDict as Dictionary<of String, Dictionary<of String, Object>>, _
+                valueStr as out String) as String
+        arg = .fixOptionArg(arg, optionPrefix)  
+        # [name, valueStr] = .splitOption(arg)
+        l   = .splitOption(arg) 
+        name     = l[0]
+        valueStr = l[1]
+        name = .validateOptionName(name, synToName, specDict)
+        return name         
+        
+            
+    def fixOptionArg(arg as String, optionPrefix as String) as String
+        """
+        Strip any leading optionPrefix chars and possibly adjust arg
+        """
+        while arg.startsWith(optionPrefix)
+            arg = arg[1:]
+            if not arg.length  # '--'
+                arg='run-args'
+        return arg
+                
+    def  splitOption(arg as String) as IList<of String>
+        """
+        Split option into name and valueStr returned as a 2 element array
+        """
+        valuePrefix = c':'
+        parts = arg.split(@[valuePrefix], 2)
+        if parts.length == 1
+            name = parts[0]
+            if name.endsWith('+')
+                name = name[:-1]
+                valueStr = 'on'
+            else if name.endsWith('-')
+                name = name[:-1]
+                valueStr = 'off'
+            else
+                valueStr = 'on'
+        else
+            assert parts.length == 2
+            name = parts[0]
+            valueStr = parts[1]
+        assert parts, name.length 
+        #assert valueStr.length
+        return [name, valueStr] 
+        
+    def isOptionSpecRestrictionViolated(optionSpec as Dictionary<of String, Object>) as bool
+        """
+        Returns true if the option spec has a 'restriction' key and the check against 
+        that restriction is true.
+        """
+        if optionSpec.containsKey('restriction')
+            branch optionSpec['restriction'] to String
+                on 'mono-only'
+                    return not CobraCore.isRunningOnMono
+        return false
+            
+    def initSynonyms(specDict as Dictionary<of String, Dictionary<of String, Object>>, _
+                    synToName as Dictionary<of String, String>, _
+                    synList as List<of String>)
+        """
+        Initialise supporting data structures for handling option synonyms
+        """
+        for d in _optionSpecs
+            if .isOptionSpecRestrictionViolated(d)
+                continue
+            specDict[d['name'] to String] = d
+            if d.containsKey('synonyms')
+                syns = d['synonyms'] to System.Collections.IList
+                for syn as String in syns
+                    assert not specDict.containsKey(syn)
+                    specDict[syn] = d
+                    synToName[syn] = d['name'] to String
+                    synList.add(syn)
+            if not d.containsKey('type')
+                d.add('type', 'string')
+            
+    def validateOptionName( name as String, _
+            synToName as Dictionary<of String, String>, _
+            specDict as Dictionary<of String, Dictionary<of String, Object>> _
+            ) as String
+        """
+        Ensure the given name exists as an option name or synonym mappableto an option name; 
+        return the canonical name for the option/synonym
+        """
+        name = Utils.getSS(synToName to passthrough, name, name) to !
+        if not specDict.containsKey(name)
+            msg = 'No such option "[name]".'
+            if name.contains('=')
+                msg += ' If you meant to specify an option value, use colon (:) instead of equals (=).'
+            .error(msg)
+        return name     
+        
+    def isAccumulatorOption(spec as Dictionary<of String,Object>) as bool
+        return  Utils.getSB(spec to passthrough, 'isAccumulator', false)
+            
+    def accumulateOptionValue(name as String, valueStr as String, _
+            valueDict as Dictionary<of String, Object>, _
+            didSpecify as Dictionary<of String, bool>)
+        # accumulators are always treated as strings. TODO: assert that
+        if valueDict.containsKey(name)
+            (valueDict[name] to System.Collections.IList).add(valueStr to passthrough)
+        else
+            valueDict[name] = [valueStr]
+            didSpecify[name] = true
+        
+            
+    def fixupDebug(valueStr as String, cannotProcess as out bool) as String
+        cannotProcess = false
+        if valueStr == 'pdbonly' or valueStr == 'full'
+            return valueStr
+            
+        value = 'no-value'  
+        try
+            b = .boolForString(valueStr)
+        catch FormatException
+            cannotProcess = true
+        success
+            value = if(b, '+', '-')
+        return value
+    
+    def processToValue(name as String,  _
+                        valueStr as String, _
+                        spec as Dictionary<of String, Object>,_
+                        mainOptions as List<of String>, _
+                        argList as IList<of String>, _
+                        argn as int, _
+                        cannotProcess as out bool, _
+                        argsDone as out bool ) as dynamic
+        value as dynamic = 'no-value'
+        argsDone = false
+        cannotProcess = false
+    
+        if name == 'debug'      # special case
+            return .fixupDebug(valueStr, out cannotProcess )
+        
+        t  = spec['type'] to String
+        branch t
+            on 'main'
+                mainOptions.add(name)
+                value = true
+            on 'args-list'
+                # remainder of args are for execution of exe file
+                _runArgs =  argList[argn:]
+                argsDone = true
+            on 'exe-args-list'
+                # remainder of args are exe file and then args for it
+                if argList.count <= argn
+                    .error("exe-args option must have at least one arg following")
+                    # TODO: fallback to default - use compile name as exe and run with no args
+                _exeFileName = argList[argn]
+                _runArgs     = argList[argn+1:]
+                argsDone = true
+            else
+                possible = .interpretValue(valueStr, spec)
+                if possible is not nil
+                    value = possible
+                else
+                    cannotProcess = true
+        return value
+                
 
+    def handleSynonyms(synList as List<of String>, _
+                        synToName as Dictionary<of String, String>, _
+                        valueDict as Dictionary<of String, Object>)
+        for syn in synList
+            if valueDict.containsKey(syn)
+                valueDict[synToName[syn]] = valueDict[syn]
+                valueDict.remove(syn)
+            
+    def addInDefaults(valueDict as Dictionary<of String, Object>)
+        for d in _optionSpecs
+            defaultName = d['name'] to String
+            if not valueDict.containsKey(defaultName) and d.containsKey('default')
+                defaultValue = .interpretValue(d['default'] to String, d) to !
+                if .verbosity
+                    print 'Setting option "[defaultName]" to default value [defaultValue].'
+                valueDict[defaultName] = defaultValue
+        
+    def unpackOptions(valueDict as Dictionary<of String, Object>, _
+                      fileList as List<of String>)  
+        """
+        Unpack certain magic options into specific class fields
+        """
+        if valueDict.containsKey('verbosity')
+            _verbosity = valueDict['verbosity'] to int
+
+        if not valueDict.containsKey('timeit') and valueDict.containsKey('testify')
+            valueDict['timeit'] = true
+        if valueDict.containsKey('timeit')
+            CobraMain.willTimeIt = valueDict['timeit'] to bool
+            
+        if valueDict.containsKey('files')
+            fileNamesList = valueDict['files'] to System.Collections.IList
+            .processFilesFile( fileNamesList, fileList)
+
+                
+    def processFilesFile(fileNamesList as IList, fileList as List<of String>)
+        """
+        Treat entries in fileNamesList as names of files containing file
+        names to compile, read and validate names and add into fileList
+        """
+        for fileName as String in fileNamesList
+            try
+                for line in File.readAllLines(fileName)
+                    line = line.trim
+                    if line.length==0 or line.startsWith('#')
+                        continue
+                    .processAsFile(line, fileList, nil)
+            catch IOException
+                .error('Cannot open file "[fileName]".')
+            
+    def  processAsFile(arg as String, fileList as List<of String>, _
+                errHint as String?)
+        """
+        Validate arg as filename and on success add into fileList
+        """
+        if File.exists(arg)
+            fileList.add(arg)
+        else if File.exists(arg+'.cobra')
+            fileList.add(arg+'.cobra')
+        else if Directory.exists(arg)
+            fileList.add(arg)
+        else 
+            msg = 'Cannot find "[arg]" as a file.'
+            if errHint 
+                msg += errHint
+            .error(msg)
+
     def computeArgImplications(options as Options)
         if options.getDefault('target', '') == 'lib' and not options.isSpecified('compile')
             options['compile'] = true
@@ -596 +731 @@
             options['include-nil-checks'] = false
             options['include-tests'] = false
             options['optimize'] = true
-
+            
     def interpretValue(valueStr as String, spec as Dictionary<of String, Object>) as dynamic?
         value as dynamic?
         branch spec['type'] to String
@@ -729 +864 @@
         if c.errors.count
             print 'Not running due to errors above.'
         else
-            p = c.runProcess
+            p = c.runProcess(_exeFileName, _runArgs)
             if _verbosity >= 1
                 print 'Running: [p.startInfo.fileName] [p.startInfo.arguments]'
                 print .verboseLineSeparator
@@ -841 +976 @@
                         first = false
                 else
                     print '        Example: -[spec["name"]]:[spec["example"]]'
+            if spec.containsKey('eg') #Verbatim example line
+                print '        e.g. [spec["eg"]]'
 
     def doAbout
         # CC: multiline string

Tests/700-command-line/700-run-args.cobra

@@ +1 @@
+# Test compile+run execution specifying args to run compiled prog with
+class Test
+    def main is shared
+        p as System.Diagnostics.Process?
+        cobraPath = CobraCore.findCobraExe
+        assert cobraPath
+        if cobraPath
+            cmdln = "702-echo -- argA argB argC"
+            output = CobraCore.runCobraExe(cobraPath, cmdln, out p)
+            #print output
+            assert 'Unhandled Exception' not in output
+            assert 'argA argB argC' in output
+            assert p.exitCode == 0
+        
+            cmdln1 = "702-echo -run-args arg1A arg1B arg1C"
+            output = CobraCore.runCobraExe(cobraPath, cmdln1, out p)
+            #print output
+            assert 'Unhandled Exception' not in output
+            assert 'arg1A arg1B arg1C' in output
+            assert p.exitCode == 0
+            

Tests/700-command-line/702-echo.cobra

@@ +1 @@
+# .skip.
+
+# used by 700-run-args.cobra
+
+class Echo
+
+    def main is shared
+        args = CobraCore.commandLineArgs
+        sep=''
+        for a in args[1:]
+            print '[sep][a]' stop
+            sep=' '
+        print

Tests/700-command-line/703-exec-args.cobra

@@ +1 @@
+# Test execution specifying cmdln args giving exe and args after compile
+#  currently -exec-args/X   Fixup when change cmdline handling
+class ExecArgs
+    def main is shared
+        p as System.Diagnostics.Process?
+        cobraPath = CobraCore.findCobraExe
+        assert cobraPath
+        if cobraPath
+            cmdln = "702-echo -exec-args 702-echo argA argB argC"
+            # chg -exec to -r/-run when change cmdline handling
+            output = CobraCore.runCobraExe(cobraPath, cmdln, out p)
+            #print output
+            assert 'Unhandled Exception' not in output
+            assert 'argA argB argC' in output
+            assert p.exitCode == 0
+        
+            cmdln1 = "702-echo -X 110-hello AnyOldArgs AnyOldargs anyAnyOldArgs"
+            output = CobraCore.runCobraExe(cobraPath, cmdln1, out p)
+            #print output
+            assert 'Unhandled Exception' not in output
+            assert 'Hello' in output
+            assert 'AnyOld' not in output
+            assert p.exitCode == 0
+            

Developer/IntermediateReleaseNotes.text

@@ -2 +2 @@
 
 * Added a new built-in doc tool accessible via "cobra -doc ...". The documentation is generated to local HTML files using your declarations, doc strings, contracts, etc.
 
+* Added support for commandline option specifying args to pass to compiled executable (-run-args) 
+ and option (-exec-args currently) to explicitly specify both executable and args to run (ticket#12) 
+
+* Added a new built-in doc tool accessible via "cobra -doc ...". The documentation is generated to local HTML files using your declarations, doc strings, contracts, etc.
+
 * Add support for specifying unsigned integers as Hex literals
     e.g. 0x7f  0x7f_8   0x7Fu16  0x7F_u32