Merge pull request #730 from zielmicha/fix-parameters

Make parseopt correct (and based on seq[string] as parameters, not string)

.gitignore

@@ -180,3 +180,4 @@ examples/cross_calculator/android/tags
 /tests/caas/main
 /tests/caasdriver
 /tools/nimgrep
+/tests/system/params

lib/pure/os.nim

@@ -1481,6 +1481,12 @@ elif not defined(createNimRtl):
 
   proc paramCount*(): int {.tags: [FReadIO].} = return cmdCount-1
 
+when defined(paramCount):
+  proc commandLineParams*(): seq[TaintedString] =
+    result = @[]
+    for i in 1..paramCount():
+      result.add(paramStr(i))
+
 when defined(linux) or defined(solaris) or defined(bsd) or defined(aix):
   proc getApplAux(procPath: string): string =
     result = newString(256)
@@ -1629,4 +1635,3 @@ proc expandTilde*(path: string): string =
     result = path
 
 {.pop.}
-

lib/pure/parseopt.nim

@@ -10,7 +10,10 @@
 ## This module provides the standard Nimrod command line parser.
 ## It supports one convenience iterator over all command line options and some
 ## lower-level features.
-
+##
+## DEPRECATED. Use parseopt2 instead as this version has issues with spaces
+## in arguments.
+{.deprecated.}
 {.push debugger: off.}
 
 include "system/inclrtl"

lib/pure/parseopt2.nim

@@ -0,0 +1,148 @@
+#
+#
+#            Nimrod's Runtime Library
+#        (c) Copyright 2012 Andreas Rumpf
+#
+#    See the file "copying.txt", included in this
+#    distribution, for details about the copyright.
+#
+
+## This module provides the standard Nimrod command line parser.
+## It supports one convenience iterator over all command line options and some
+## lower-level features.
+##
+## Supported syntax:
+##
+## 1. short options - ``-abcd``, where a, b, c, d are names
+## 2. long option - ``--foo:bar``, ``--foo=bar`` or ``--foo``
+## 3. argument - everything else
+
+{.push debugger: off.}
+
+include "system/inclrtl"
+
+import
+  os, strutils
+
+type
+  TCmdLineKind* = enum        ## the detected command line token
+    cmdEnd,                   ## end of command line reached
+    cmdArgument,              ## argument detected
+    cmdLongOption,            ## a long option ``--option`` detected
+    cmdShortOption            ## a short option ``-c`` detected
+  TOptParser* =
+      object of TObject ## this object implements the command line parser
+    cmd: seq[string]
+    pos: int
+    remainingShortOptions: string
+    kind*: TCmdLineKind       ## the dected command line token
+    key*, val*: TaintedString ## key and value pair; ``key`` is the option
+                              ## or the argument, ``value`` is not "" if
+                              ## the option was given a value
+
+proc initOptParser*(cmdline: seq[string]): TOptParser {.rtl.} =
+  ## Initalizes option parses with cmdline. cmdline should not contain
+  ## argument 0 - program name.
+  ## If cmdline == nil default to current command line arguments.
+  result.remainingShortOptions = ""
+  when not defined(createNimRtl):
+    if cmdline == nil:
+      result.cmd = commandLineParams()
+      return
+  else:
+    assert cmdline != nil, "Cannot determine command line arguments."
+
+  result.cmd = @cmdline
+
+proc initOptParser*(cmdline: string): TOptParser {.rtl, deprecated.} =
+  ## Initalizes option parses with cmdline. Splits cmdline in on spaces
+  ## and calls initOptParser(openarray[string])
+  ## Do not use.
+  if cmdline == "": # backward compatibilty
+    return initOptParser(seq[string](nil))
+  else:
+    return initOptParser(cmdline.split)
+
+when not defined(createNimRtl):
+  proc initOptParser*(): TOptParser =
+    ## Initializes option parser from current command line arguments.
+    return initOptParser(commandLineParams())
+
+proc next*(p: var TOptParser) {.rtl, extern: "npo$1".}
+
+proc nextOption(p: var TOptParser, token: string, allowEmpty: bool) =
+  for splitchar in [':', '=']:
+    if splitchar in token:
+      let pos = token.find(splitchar)
+      p.key = token[0..pos-1]
+      p.val = token[pos+1..token.len-1]
+      return
+
+  p.key = token
+  if allowEmpty:
+    p.val = ""
+  else:
+    p.remainingShortOptions = token[0..token.len-1]
+    p.next()
+
+proc next(p: var TOptParser) =
+  if p.remainingShortOptions.len != 0:
+    p.kind = cmdShortOption
+    p.key = TaintedString(p.remainingShortOptions[0..0])
+    p.val = ""
+    p.remainingShortOptions = p.remainingShortOptions[1..p.remainingShortOptions.len-1]
+    return
+
+  if p.pos >= p.cmd.len:
+    p.kind = cmdEnd
+    return
+
+  let token = p.cmd[p.pos]
+  p.pos += 1
+
+  if token.startswith("--"):
+    p.kind = cmdLongOption
+    nextOption(p, token[2..token.len-1], allowEmpty=true)
+  elif token.startswith("-"):
+    p.kind = cmdShortOption
+    nextOption(p, token[1..token.len-1], allowEmpty=true)
+  else:
+    p.kind = cmdArgument
+    p.key = token
+    p.val = ""
+
+proc cmdLineRest*(p: TOptParser): TaintedString {.rtl, extern: "npo$1", deprecated.} =
+  ## Returns part of command line string that has not been parsed yet.
+  ## Do not use - does not correctly handle whitespace.
+  return p.cmd[p.pos..p.cmd.len-1].join(" ")
+
+type
+  TGetoptResult* = tuple[kind: TCmdLineKind, key, val: TaintedString]
+
+when defined(paramCount):
+  iterator getopt*(): TGetoptResult =
+    ## This is an convenience iterator for iterating over the command line.
+    ## This uses the TOptParser object. Example:
+    ##
+    ## .. code-block:: nimrod
+    ##   var
+    ##     filename = ""
+    ##   for kind, key, val in getopt():
+    ##     case kind
+    ##     of cmdArgument:
+    ##       filename = key
+    ##     of cmdLongOption, cmdShortOption:
+    ##       case key
+    ##       of "help", "h": writeHelp()
+    ##       of "version", "v": writeVersion()
+    ##     of cmdEnd: assert(false) # cannot happen
+    ##   if filename == "":
+    ##     # no filename has been given, so we show the help:
+    ##     writeHelp()
+    var p = initOptParser()
+    while true:
+      next(p)
+      if p.kind == cmdEnd: break
+      yield (p.kind, p.key, p.val)
+
+{.pop.}

tests/system/params.nim

@@ -0,0 +1,18 @@
+import os
+import osproc
+import parseopt2
+import sequtils
+
+let argv = commandLineParams()
+
+if argv == @[]:
+  # this won't work with spaces
+  assert execShellCmd(getAppFilename() & " \"foo bar\" --aa:bar=a --a=c:d --ab -c --a[baz]:doo") == 0
+else:
+  let f = toSeq(getopt())
+  echo f.repr
+  assert f[0].kind == cmdArgument and f[0].key == "foo bar" and f[0].val == ""
+  assert f[1].kind == cmdLongOption and f[1].key == "aa" and f[1].val == "bar=a"
+  assert f[2].kind == cmdLongOption and f[2].key == "a=c" and f[2].val == "d"
+  assert f[3].kind == cmdLongOption and f[3].key == "ab" and f[3].val == ""
+  assert f[4].kind == cmdShortOption and f[4].key == "c" and f[4].val == ""