Tidy up the prettification of the default verbosity c compilation output

compiler/extccomp.nim

@@ -596,21 +596,24 @@ proc callCCompiler*(projectfile: string) =
   var script: PRope = nil
   var cmds: TStringSeq = @[]
   var prettyCmds: TStringSeq = @[]
+  let prettyCb = proc (idx: int) =
+    echo prettyCmds[idx]
   compileCFile(toCompile, script, cmds, prettyCmds, false)
   compileCFile(externalToCompile, script, cmds, prettyCmds, true)
-  if gVerbosity != 1:
-      prettyCmds = @[]
   if optCompileOnly notin gGlobalOptions: 
     if gNumberOfProcessors == 0: gNumberOfProcessors = countProcessors()
     var res = 0
     if gNumberOfProcessors <= 1: 
       for i in countup(0, high(cmds)): res = max(execCmd(cmds[i]), res)
-    elif optListCmd in gGlobalOptions or gVerbosity > 0: 
+    elif optListCmd in gGlobalOptions or gVerbosity > 1:
       res = execProcesses(cmds, {poEchoCmd, poUseShell, poParentStreams},
-                          gNumberOfProcessors, prettyCmds)
-    else: 
+                          gNumberOfProcessors)
+    elif gVerbosity == 1:
       res = execProcesses(cmds, {poUseShell, poParentStreams},
-                          gNumberOfProcessors, prettyCmds)
+                          gNumberOfProcessors, prettyCb)
+    else:
+      res = execProcesses(cmds, {poUseShell, poParentStreams},
+                          gNumberOfProcessors)
     if res != 0:
       if gNumberOfProcessors <= 1:
         rawMessage(errExecutionOfProgramFailed, [])

lib/pure/osproc.nim

@@ -236,31 +236,23 @@ proc countProcessors*(): int {.rtl, extern: "nosp$1".} =
 proc execProcesses*(cmds: openArray[string],
                     options = {poStdErrToStdOut, poParentStreams},
                     n = countProcessors(),
-                    prettyCmds: openArray[string] = @[]): int
-                    {.rtl, extern: "nosp$1",
-                    tags: [ExecIOEffect, TimeEffect, ReadEnvEffect]} =
+                    beforeRunEvent: proc(idx: int){.closure.}): int
+                    {.rtl, tags: [ExecIOEffect, TimeEffect, ReadEnvEffect]} =
   ## executes the commands `cmds` in parallel. Creates `n` processes
   ## that execute in parallel. The highest return value of all processes
-  ## is returned. If `prettyCmds` are provided, prints them on the console
-  ## instead of the real commands (for prettier output).
-  var options = options
+  ## is returned. Runs `beforeRunEvent` before running each command.
   when defined(posix):
     # poParentStreams causes problems on Posix, so we simply disable it:
-    options = options - {poParentStreams}
+    var options = options - {poParentStreams}
 
   assert n > 0
-  var usePrettyPrintouts = false
-  if prettyCmds.len == cmds.len:
-    options = options - {poEchoCmd}
-    usePrettyPrintouts = true
   if n > 1:
     var q: seq[Process]
     newSeq(q, n)
     var m = min(n, cmds.len)
     for i in 0..m-1:
+      beforeRunEvent(i)
       q[i] = startCmd(cmds[i], options=options)
-      if usePrettyPrintouts:
-        echo prettyCmds[i]
     when defined(noBusyWaiting):
       var r = 0
       for i in m..high(cmds):
@@ -273,9 +265,8 @@ proc execProcesses*(cmds: openArray[string],
           echo(err)
         result = max(waitForExit(q[r]), result)
         if q[r] != nil: close(q[r])
+        beforeRunEvent(i)
         q[r] = startCmd(cmds[i], options=options)
-        if usePrettyPrintouts:
-          echo prettyCmds[i]
         r = (r + 1) mod n
     else:
       var i = m
@@ -286,22 +277,31 @@ proc execProcesses*(cmds: openArray[string],
             #echo(outputStream(q[r]).readLine())
             result = max(waitForExit(q[r]), result)
             if q[r] != nil: close(q[r])
+            beforeRunEvent(i)
             q[r] = startCmd(cmds[i], options=options)
-            if usePrettyPrintouts:
-              echo prettyCmds[i]
             inc(i)
             if i > high(cmds): break
     for j in 0..m-1:
       result = max(waitForExit(q[j]), result)
       if q[j] != nil: close(q[j])
   else:
     for i in 0..high(cmds):
+      beforeRunEvent(i)
       var p = startCmd(cmds[i], options=options)
-      if usePrettyPrintouts:
-        echo prettyCmds[i]
       result = max(waitForExit(p), result)
       close(p)
 
+let emptyCb = proc(idx: int) {.closure.} = discard
+proc execProcesses*(cmds: openArray[string],
+                    options = {poStdErrToStdOut, poParentStreams},
+                    n = countProcessors()): int
+                    {.rtl, extern: "nosp$1",
+                    tags: [ExecIOEffect, TimeEffect, ReadEnvEffect]} =
+  ## executes the commands `cmds` in parallel. Creates `n` processes
+  ## that execute in parallel. The highest return value of all processes
+  ## is returned.
+  return execProcesses(cmds, options, n, emptyCb)
+
 proc select*(readfds: var seq[Process], timeout = 500): int
   ## `select` with a sensible Nim interface. `timeout` is in miliseconds.
   ## Specify -1 for no timeout. Returns the number of processes that are