Builder = ref BuilderObj

BuilderObj {.acyclic.} = object
  name*: string ## Command name for subcommand parsers, or program name for
                ## the parent parser.
  symbol*: string ## Unique tag to apply to Parser and Option types to avoid
                  ## conflicts.  By default, this is generated with Nim's
                  ## gensym algorithm.
  components*: seq[Component]
  help*: string
  groupName*: string
  children*: seq[Builder]
  parent*: Option[Builder]
  runProcBodies*: seq[NimNode]

Component = object
  varname*: string
  hidden*: bool
  help*: string
  env*: string
  case kind*: ComponentKind
  of ArgFlag:
      flagShort*: string
      flagLong*: string
      flagMultiple*: bool
      shortCircuit*: bool

  of ArgOption:
      optShort*: string
      optLong*: string
      optMultiple*: bool
      optDefault*: Option[string]
      optChoices*: seq[string]
      optRequired*: bool

  of ArgArgument:
      nargs*: int
      argDefault*: Option[string]

  

ComponentKind = enum
  ArgFlag, ArgOption, ArgArgument

GenResponse = tuple[types: NimNode, procs: NimNode, instance: NimNode]

ParseState = object
  tokens*: seq[string]
  cursor*: int
  extra*: seq[string]        ## tokens that weren't parsed
  done*: bool
  token*: Option[string]     ## The current unprocessed token
  key*: Option[string]       ## The current key (possibly the head of a 'key=value' token)
  value*: Option[string]     ## The current value (possibly the tail of a 'key=value' token)
  valuePartOfToken*: bool    ## true if the value is part of the current token (e.g. 'key=value')
  runProcs*: seq[proc ()]    ## Procs to be run at the end of parsing
  

ShortCircuit = object of CatchableError
  flag*: string
  help*: string

UsageError = object of ValueError

ARGPARSE_STDOUT = newFileStream(stdout)

builderStack = newSeq(Natural(0))

proc `$`(b: Builder): string {....raises: [], tags: [].}

proc `$`(state: ref ParseState): string {.inline, ...raises: [], tags: [].}

proc add_command(name: string; group: string; content: proc ()) {.compileTime,
    ...raises: [], tags: [].}

proc add_runProc(body: NimNode) {.compileTime, ...raises: [], tags: [].}

proc addParser(name: string; group: string; content: proc ()): Builder {.
    ...raises: [], tags: [].}

proc allChildren(builder: Builder): seq[Builder] {....raises: [], tags: [].}

proc consume(state: ref ParseState; thing: ComponentKind) {....raises: [], tags: [].}

proc generateDefs(builder: Builder): NimNode {....raises: [ValueError, KeyError],
    tags: [].}

proc getHelpText(b: Builder): string {....raises: [ValueError, KeyError], tags: [].}

proc helpProcDef(b: Builder): NimNode {....raises: [ValueError, KeyError], tags: [].}

proc newBuilder(name = ""): Builder {....raises: [], tags: [].}

proc newParseState(args: openArray[string]): ref ParseState {....raises: [],
    tags: [].}

proc optsTypeDef(b: Builder): NimNode {....raises: [ValueError], tags: [].}

proc parseProcDef(b: Builder): NimNode {....raises: [ValueError], tags: [].}

proc parserTypeDef(b: Builder): NimNode {....raises: [], tags: [].}

proc popleft[T](s: var seq[T]): T

proc popright[T](s: var seq[T]; n = 0): T

proc raiseShortCircuit(flagname: string; help: string) {.inline,
    ...raises: [ShortCircuit], tags: [].}

proc setOrAdd(x: var seq[string]; val: string) {....raises: [], tags: [].}

proc setOrAdd(x: var string; val: string) {....raises: [], tags: [].}

proc skip(state: ref ParseState) {.inline, ...raises: [], tags: [].}

proc toVarname(x: string): string {....raises: [], tags: [].}