Ticket #35: compilerDirectiveTgtDll.patch

Source/Compiler.cobra

@@ -80 +80 @@
     var _fullExeFileName as String = ''
 
     var _clrTypeCache as Dictionary<of String, System.Type>
+    var _canRun as bool     # false if lib or module built
 
 
     # caches
@@ -106 +107 @@
         _messagesPerSourceLine = Dictionary<of String, List<of SourceException>>()
         _errors = List<of SourceException>()
         _warnings = List<of SourceException>()
+        _canRun = true
         _intermediateFileNames = List<of String>()
         _clrTypeCache = Dictionary<of String, System.Type>()
         if initialModules
@@ -181 +183 @@
     get warnings from var
 
     get messages from var
-
+    
+    get canRun from var
+    
     pro htmlWriter from var
         """
         Set this to support the output-html command line option.
@@ -576 +580 @@
 
         t = System.Diagnostics.Process.getType
         .readAssembly(t.assembly) # System.dll
-
+        
+    def _appendLibSuffix(libName as String) as String
+        if not libName.endsWith('.dll') and not libName.endsWith('.exe')
+            libName += '.dll'
+        return libName
+        
     def readAssemblyTypes
         references = .options.getDefault('reference', List<of String>()) to List<of String>
 
         # Excluding the extension can be problematic
         i = 0
         for reference in List<of String>(references)
-            if not reference.endsWith('.dll') and not reference.endsWith('.exe')
-                reference += '.dll'
+            reference = _appendLibSuffix(reference)
+            if reference is not references[i]
                 references[i] = reference
             i += 1
 
@@ -624 +633 @@
         # $sharp('curDomain.ReflectionOnlyAssemblyResolve += _resolveEvent')
 
         for reference in references
-            if .verbosity > 0
-                print 'Loading reference:', reference
-            if false
-                # Does not work on Novell Mono. See notes above.
-                referredAss = Assembly.reflectionOnlyLoadFrom(reference)
-                # TODO: handle all the exceptions from Assembly.loadFrom
-            else
-                if File.exists(reference)
-                    # try current directory
-                    referredAss = Assembly.loadFrom(reference)
-                else
-                    # TODO: the problem with -lib: in both Cobra and C# is that it has no effect on runtime,
-                    # you must still register the DLLs in the GAC or copy them into the same dir as the .exe
-                    # because the -lib: paths are not passed into executable.
-                    # So should Cobra copy the .dll's into the target directory (if their paths are not in MONO_PATH)?
-                    searchPaths = .options.getDefault('library-directory', List<of String>()) to List<of String>
-                    # TODO: ?: searchPaths.add(Path.getDirectoryName(Assembly.getExecutingAssembly.location))  # try Cobra's directory - also should be added to .options.'library-directory' not to a local var
-                    found = false
-                    for searchPath in searchPaths
-                        combinedPath = Path.combine(searchPath, reference)
-                        if File.exists(combinedPath)
-                            referredAss = Assembly.loadFrom(combinedPath)
-                            found = true
-                            break
-                    if not found
-                        # try system wide (GAC)
-                        if reference.endsWith('.dll')
-                            reference = reference[:-4]
-                        referredAss = Utils.loadWithPartialName(reference)
-                # TODO: handle all the exceptions from Assembly.loadFrom
-            if referredAss
-                .readAssembly(referredAss, reference <> 'Cobra.Lang.dll')
-            else
-                _addMessage(SourceException('Cannot locate assembly reference "[reference]".'))
+            _loadAssemblyForRef(reference)
             i += 1
 
+    def _loadAssemblyForRef(reference as String)        
+        if .verbosity > 0
+            print 'Loading reference:', reference
+        if false
+            # Does not work on Novell Mono. See notes above.
+            referredAss = Assembly.reflectionOnlyLoadFrom(reference)
+            # TODO: handle all the exceptions from Assembly.loadFrom
+        else
+            if File.exists(reference)
+                # try current directory
+                referredAss = Assembly.loadFrom(reference)
+            else
+                # TODO: the problem with -lib: in both Cobra and C# is that it has no effect on runtime,
+                # you must still register the DLLs in the GAC or copy them into the same dir as the .exe
+                # because the -lib: paths are not passed into executable.
+                # So should Cobra copy the .dll's into the target directory (if their paths are not in MONO_PATH)?
+                searchPaths = .options.getDefault('library-directory', List<of String>()) to List<of String>
+                # TODO: ?: searchPaths.add(Path.getDirectoryName(Assembly.getExecutingAssembly.location))  # try Cobra's directory - also should be added to .options.'library-directory' not to a local var
+                found = false
+                for searchPath in searchPaths
+                    combinedPath = Path.combine(searchPath, reference)
+                    if File.exists(combinedPath)
+                        referredAss = Assembly.loadFrom(combinedPath)
+                        found = true
+                        break
+                if not found
+                    # try system wide (GAC)
+                    if reference.endsWith('.dll')
+                        reference = reference[:-4]
+                    referredAss = Utils.loadWithPartialName(reference)
+            # TODO: handle all the exceptions from Assembly.loadFrom
+        if referredAss
+            .readAssembly(referredAss, reference <> 'Cobra.Lang.dll')
+        else
+            _addMessage(SourceException('Cannot locate assembly reference "[reference]".'))
+
     def refsForPackage(pkgName as String) as List<of String>
         """
         Returns the library/DLL refs for the give package name.
@@ -1139 +1151 @@
         else
             throw FallThroughException('found [name], but it is not an IType. it is [thing]')
 
+    def setTarget(tgt as String)
+        require tgt in ['exe', 'winexe', 'lib', 'module']
+        # override Target if not already set (fm cmdline)
+        if not .options.isSpecified('target')
+            if .verbosity, print 'setTarget=[tgt]'
+            .options['target'] = tgt
+            .options.didSpecify('target')
+        else    
+            if .verbosity, print 'setTarget: Not set options.target to [tgt], target already set'
+            
+    def addDllReference(libName as String)
+        if not libName.length
+            return
+        if not .options.containsKey('reference')
+            .options['reference'] = List<of String>()
+            .options.didSpecify('reference')
+        refs = .options['reference'] to List<of String>
+        if libName not in refs
+            if .verbosity, print 'Adding reference to "[libName]"'
+            libName = _appendLibSuffix(libName)
+            refs.add(libName)
+            _loadAssemblyForRef(libName)
+        else
+            if .verbosity, print 'Reference "[libName]" already in options.ref'
+            
     def suggestionFor(name as String) as String? is shared
         require name.length
         # CC: return _unknownSuggestions.getDefault(name, nil)
@@ -1380 +1417 @@
             else
                 outName += '.exe'
             _fullExeFileName = outName
+            _canRun = options.getDefault('target', 'exe') in ['exe', 'winexe']
 
             delaySign = options.boolValue('delay-sign')
             if delaySign
@@ -1465 +1503 @@
                 cp.generateExecutable = options.getDefault('target', 'exe') in ['exe', 'winexe']
                 cp.outputAssembly = _fullExeFileName
                 cp.compilerOptions = backEndOptions
+                if _verbosity >= 2
+                    print '[cp] [backEndOptions][sharpFileNameList]'
                 #trace backEndOptions
                 #trace sharpFileNameList
                 cr = provider.compileAssemblyFromFile(cp, sharpFileNameList.toArray)
@@ -1498 +1538 @@
                     _parseSharpCompilerOutput(output)
 
             if .errors.count
+                _canRun = false
                 _exitFromErrors
 
             # remove intermediate files such as *.cobra.cs

Source/CommandLine.cobra

@@ -728 +728 @@
         c = .doCompile(paths, false, false, false)
         if c.errors.count
             print 'Not running due to errors above.'
-        else
+        else if c.canRun
             p = c.runProcess
             if _verbosity >= 1
                 print 'Running: [p.startInfo.fileName] [p.startInfo.arguments]'

Source/CobraParser.cobra

@@ -533 +533 @@
         return _module to !
 
     def compilerDirective
+        compiler = .typeProvider to Compiler?
+        if not compiler
+            trace
+            .throwError("Internal: Cannot get compiler from .typeProvider")
+            
         .expect('PERCENTPERCENT')
         # 'stop' is already handled in main parse loop
         token = .grab
         branch token.text
             on 'throw'
+                msg = .optional('STRING_SINGLE','STRING_DOUBLE')    
+                if msg
+                    print '%%> [msg.text]'
+                    .throwError('Compilation Stopped due CompilerDirective "throw"')
                 # throw an internal error. used for testing that the compiler will catch and report these as internal errors
                 .expect('EOL')
                 # TODO: throw AssertException(SourceSite sourceSite, object[] expressions, object thiss, object info)
@@ -548 +557 @@
                 if typeName.text not in ['decimal', 'float', 'float32', 'float64']
                     .throwError('Compiler directive "number": unrecognized type "[typeName.text]". Must be one of "decimal", "float", "float32" or "float64".')
                 .expect('EOL')
-                comp = .typeProvider to Compiler?
-                if comp, comp.numberTypeName = typeName.text
+                compiler.numberTypeName = typeName.text
+            on 'target' or 'Target'     
+                # Target 'exe' | 'winexe' | 'lib' | 'module'
+                tgt = .expect('ID')
+                tgtVal =  tgt.text
+                if tgtVal not in ['exe', 'winexe', 'lib', 'module']
+                    .throwError("Target value '[tgtVal]' not one of 'exe', 'winexe', 'lib', 'module'")
+                .expect('EOL')
+                compiler.setTarget(tgtVal)    
+            on 'reference' or 'Reference'  # pending 'use X.Y' autoref-ing X.Y.dll 
+                # Reference dllName     e.g reference System.Windows.Forms[.dll]
+                n = .peek
+                if n and n.which == 'STRING_DOUBLE'    # dbl quoted form "System.Windows.Forms"
+                    id = .expect('STRING_DOUBLE')
+                    dllRef = id.text[1:id.text.length-1]
+                else                                    # dot sep IDstream System.Windows.Forms
+                    names = List<of String>()    
+                    while true
+                        id = .expect('ID')
+                        names.add(id.text)
+                        dot = .optional('DOT')
+                        if not dot
+                            break
+                    dllRef = Utils.join('.', names)
+                .endOfLine
+                compiler.addDllReference(dllRef)
+            # ++ 'embed-run-time'   ??
             else
-                .throwError('Unknown compiler directive.')
+                .throwError('Unknown compiler directive [token.text].')
 
     def useDirective as UseDirective
         """

Tests/700-command-line/800-foolib1.cobra

@@ +1 @@
+# .args. -embed-run-time:no
+%% target lib
+
+class Foo
+
+    get one as int
+        return 1
+
+    get two as int
+        return 2
+
+    get name as String
+        return .getType.name
+
+    def computeString as String
+        return 'aoeuaoeu'
+
+    def checkInts(args as vari int) as int
+        for arg in args
+            assert arg
+        return args.length

Tests/700-command-line/801-reference-gac-lib.cobra

@@ +1 @@
+# 
+%% reference System.Xml
+use System.Xml
+
+class Test
+
+    def main is shared
+        xDoc = XmlDocument()
+        #xDoc.load('filename.xml')
+        xDoc.loadXml('<xml> <name>Cobra</name> <url>http://Cobra-Language.com/</url> </xml>')
+        name = xDoc.getElementsByTagName('name') # an XmlNodeList
+        url = xDoc.getElementsByTagName('url')
+        assert name.item(0).innerText == 'Cobra'
+        assert url.item(0).innerText.startsWith('http://')

Tests/700-command-line/404-fooprog.cobra

@@ -1 +1 @@
 # .args. -embed-run-time:no -r:400-foolib
 
-# same as other fooprog, but the -r arg does not include the ".dll" extension -- both ways should work
+# same as other 400-fooprog, but the -r arg does not include the ".dll" extension -- both ways should work
 
 class Program
 

Tests/700-command-line/802-fooprog.cobra

@@ +1 @@
+# .args. -embed-run-time:no 
+%% reference "800-foolib1.dll"
+
+class Program
+
+    def main is shared
+        f = Foo()
+        print f.one
+        print f.two
+        name = f.name
+        .checkName(name)
+        s = f.computeString
+        .checkName(s)
+        assert f.checkInts(2, 4, 6) == 3
+
+    def checkName(name as String) is shared
+        assert name.length

Tests/700-command-line/804-fooprog.cobra

@@ +1 @@
+# .args. -embed-run-time:no
+%% reference "800-foolib1"
+
+# same as other 800-fooprog, but the %% reference arg does not include the ".dll" extension -- both ways should work
+
+class Program
+
+    def main is shared
+        f = Foo()
+        print f.one
+        print f.two

Developer/IntermediateReleaseNotes.text

@@ -3 +3 @@
 * Add support for commenting full blocks of lines using /# and #/. Block comments can be nested.
     '/#' block comment start and  '#/' block comment end as initial chars on line
 
+* Added support for compiler directive to specify the target type same as 
+    command line -target option
+    %% [Tt]arget  'exe' | 'winexe' | 'lib' | 'module'
+
+* Added support for compiler directive to add a DLL reference same as 
+    command line -reference option
+    %% [Rr]eference  some.qualified.dll   and
+    %% [Rr]eference  "some.numbered-100.DllName"
+    
+    
 * Added support for a Cobra compiler directive to specify the type for `number`
     type of number and integer literals same as command line -number option
     %% number  'decimal' | 'float' | 'float32' | 'float64'