refactoring: explict config state instead of globals

1 files changed, 53 insertions, 53 deletions

diff --git a/compiler/nimconf.nim b/compiler/nimconf.nim
index 4bf2fbc9a..808159b8f 100644
--- a/compiler/nimconf.nim
+++ b/compiler/nimconf.nim
@@ -21,37 +21,37 @@ proc ppGetTok(L: var TLexer, tok: var TToken) =
   rawGetTok(L, tok)
   while tok.tokType in {tkComment}: rawGetTok(L, tok)
 
-proc parseExpr(L: var TLexer, tok: var TToken): bool
-proc parseAtom(L: var TLexer, tok: var TToken): bool =
+proc parseExpr(L: var TLexer, tok: var TToken; config: ConfigRef): bool
+proc parseAtom(L: var TLexer, tok: var TToken; config: ConfigRef): bool =
   if tok.tokType == tkParLe:
     ppGetTok(L, tok)
-    result = parseExpr(L, tok)
+    result = parseExpr(L, tok, config)
     if tok.tokType == tkParRi: ppGetTok(L, tok)
     else: lexMessage(L, errTokenExpected, "\')\'")
   elif tok.ident.id == ord(wNot):
     ppGetTok(L, tok)
-    result = not parseAtom(L, tok)
+    result = not parseAtom(L, tok, config)
   else:
     result = isDefined(tok.ident)
     ppGetTok(L, tok)
 
-proc parseAndExpr(L: var TLexer, tok: var TToken): bool =
-  result = parseAtom(L, tok)
+proc parseAndExpr(L: var TLexer, tok: var TToken; config: ConfigRef): bool =
+  result = parseAtom(L, tok, config)
   while tok.ident.id == ord(wAnd):
     ppGetTok(L, tok)          # skip "and"
-    var b = parseAtom(L, tok)
+    var b = parseAtom(L, tok, config)
     result = result and b
 
-proc parseExpr(L: var TLexer, tok: var TToken): bool =
-  result = parseAndExpr(L, tok)
+proc parseExpr(L: var TLexer, tok: var TToken; config: ConfigRef): bool =
+  result = parseAndExpr(L, tok, config)
   while tok.ident.id == ord(wOr):
     ppGetTok(L, tok)          # skip "or"
-    var b = parseAndExpr(L, tok)
+    var b = parseAndExpr(L, tok, config)
     result = result or b
 
-proc evalppIf(L: var TLexer, tok: var TToken): bool =
+proc evalppIf(L: var TLexer, tok: var TToken; config: ConfigRef): bool =
   ppGetTok(L, tok)            # skip 'if' or 'elif'
-  result = parseExpr(L, tok)
+  result = parseExpr(L, tok, config)
   if tok.tokType == tkColon: ppGetTok(L, tok)
   else: lexMessage(L, errTokenExpected, "\':\'")
 
@@ -66,20 +66,20 @@ type
   TJumpDest = enum
     jdEndif, jdElseEndif
 
-proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest)
-proc doElse(L: var TLexer, tok: var TToken) =
+proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest; config: ConfigRef)
+proc doElse(L: var TLexer, tok: var TToken; config: ConfigRef) =
   if high(condStack) < 0: lexMessage(L, errTokenExpected, "@if")
   ppGetTok(L, tok)
   if tok.tokType == tkColon: ppGetTok(L, tok)
-  if condStack[high(condStack)]: jumpToDirective(L, tok, jdEndif)
+  if condStack[high(condStack)]: jumpToDirective(L, tok, jdEndif, config)
 
-proc doElif(L: var TLexer, tok: var TToken) =
+proc doElif(L: var TLexer, tok: var TToken; config: ConfigRef) =
   if high(condStack) < 0: lexMessage(L, errTokenExpected, "@if")
-  var res = evalppIf(L, tok)
-  if condStack[high(condStack)] or not res: jumpToDirective(L, tok, jdElseEndif)
+  var res = evalppIf(L, tok, config)
+  if condStack[high(condStack)] or not res: jumpToDirective(L, tok, jdElseEndif, config)
   else: condStack[high(condStack)] = true
 
-proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest) =
+proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest; config: ConfigRef) =
   var nestedIfs = 0
   while true:
     if tok.ident != nil and tok.ident.s == "@":
@@ -89,11 +89,11 @@ proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest) =
         inc(nestedIfs)
       of wElse:
         if dest == jdElseEndif and nestedIfs == 0:
-          doElse(L, tok)
+          doElse(L, tok, config)
           break
       of wElif:
         if dest == jdElseEndif and nestedIfs == 0:
-          doElif(L, tok)
+          doElif(L, tok, config)
           break
       of wEnd:
         if nestedIfs == 0:
@@ -108,16 +108,16 @@ proc jumpToDirective(L: var TLexer, tok: var TToken, dest: TJumpDest) =
     else:
       ppGetTok(L, tok)
 
-proc parseDirective(L: var TLexer, tok: var TToken) =
+proc parseDirective(L: var TLexer, tok: var TToken; config: ConfigRef) =
   ppGetTok(L, tok)            # skip @
   case whichKeyword(tok.ident)
   of wIf:
     setLen(condStack, len(condStack) + 1)
-    let res = evalppIf(L, tok)
+    let res = evalppIf(L, tok, config)
     condStack[high(condStack)] = res
-    if not res: jumpToDirective(L, tok, jdElseEndif)
-  of wElif: doElif(L, tok)
-  of wElse: doElse(L, tok)
+    if not res: jumpToDirective(L, tok, jdElseEndif, config)
+  of wElif: doElif(L, tok, config)
+  of wElse: doElse(L, tok, config)
   of wEnd: doEnd(L, tok)
   of wWrite:
     ppGetTok(L, tok)
@@ -146,58 +146,58 @@ proc parseDirective(L: var TLexer, tok: var TToken) =
       ppGetTok(L, tok)
     else: lexMessage(L, errInvalidDirectiveX, tokToStr(tok))
 
-proc confTok(L: var TLexer, tok: var TToken) =
+proc confTok(L: var TLexer, tok: var TToken; config: ConfigRef) =
   ppGetTok(L, tok)
   while tok.ident != nil and tok.ident.s == "@":
-    parseDirective(L, tok)    # else: give the token to the parser
+    parseDirective(L, tok, config)    # else: give the token to the parser
 
 proc checkSymbol(L: TLexer, tok: TToken) =
   if tok.tokType notin {tkSymbol..pred(tkIntLit), tkStrLit..tkTripleStrLit}:
     lexMessage(L, errIdentifierExpected, tokToStr(tok))
 
-proc parseAssignment(L: var TLexer, tok: var TToken) =
+proc parseAssignment(L: var TLexer, tok: var TToken; config: ConfigRef) =
   if tok.ident.s == "-" or tok.ident.s == "--":
-    confTok(L, tok)           # skip unnecessary prefix
+    confTok(L, tok, config)           # skip unnecessary prefix
   var info = getLineInfo(L, tok) # save for later in case of an error
   checkSymbol(L, tok)
   var s = tokToStr(tok)
-  confTok(L, tok)             # skip symbol
+  confTok(L, tok, config)             # skip symbol
   var val = ""
   while tok.tokType == tkDot:
     add(s, '.')
-    confTok(L, tok)
+    confTok(L, tok, config)
     checkSymbol(L, tok)
     add(s, tokToStr(tok))
-    confTok(L, tok)
+    confTok(L, tok, config)
   if tok.tokType == tkBracketLe:
     # BUGFIX: val, not s!
     # BUGFIX: do not copy '['!
-    confTok(L, tok)
+    confTok(L, tok, config)
     checkSymbol(L, tok)
     add(val, tokToStr(tok))
-    confTok(L, tok)
-    if tok.tokType == tkBracketRi: confTok(L, tok)
+    confTok(L, tok, config)
+    if tok.tokType == tkBracketRi: confTok(L, tok, config)
     else: lexMessage(L, errTokenExpected, "']'")
     add(val, ']')
   let percent = tok.ident != nil and tok.ident.s == "%="
   if tok.tokType in {tkColon, tkEquals} or percent:
     if len(val) > 0: add(val, ':')
-    confTok(L, tok)           # skip ':' or '=' or '%'
+    confTok(L, tok, config)           # skip ':' or '=' or '%'
     checkSymbol(L, tok)
     add(val, tokToStr(tok))
-    confTok(L, tok)           # skip symbol
+    confTok(L, tok, config)           # skip symbol
     while tok.ident != nil and tok.ident.s == "&":
-      confTok(L, tok)
+      confTok(L, tok, config)
       checkSymbol(L, tok)
       add(val, tokToStr(tok))
-      confTok(L, tok)
+      confTok(L, tok, config)
   if percent:
     processSwitch(s, strtabs.`%`(val, options.gConfigVars,
-                                {useEnvironment, useEmpty}), passPP, info)
+                                {useEnvironment, useEmpty}), passPP, info, config)
   else:
-    processSwitch(s, val, passPP, info)
+    processSwitch(s, val, passPP, info, config)
 
-proc readConfigFile(filename: string; cache: IdentCache) =
+proc readConfigFile(filename: string; cache: IdentCache; config: ConfigRef) =
   var
     L: TLexer
     tok: TToken
@@ -207,8 +207,8 @@ proc readConfigFile(filename: string; cache: IdentCache) =
     initToken(tok)
     openLexer(L, filename, stream, cache)
     tok.tokType = tkEof       # to avoid a pointless warning
-    confTok(L, tok)           # read in the first token
-    while tok.tokType != tkEof: parseAssignment(L, tok)
+    confTok(L, tok, config)           # read in the first token
+    while tok.tokType != tkEof: parseAssignment(L, tok, config)
     if len(condStack) > 0: lexMessage(L, errTokenExpected, "@end")
     closeLexer(L)
     rawMessage(hintConf, filename)
@@ -225,22 +225,22 @@ proc getSystemConfigPath(filename: string): string =
     if not existsFile(result): result = joinPath([p, "etc", filename])
     if not existsFile(result): result = "/etc/" & filename
 
-proc loadConfigs*(cfg: string; cache: IdentCache) =
+proc loadConfigs*(cfg: string; cache: IdentCache; config: ConfigRef = nil) =
   setDefaultLibpath()
 
   if optSkipConfigFile notin gGlobalOptions:
-    readConfigFile(getSystemConfigPath(cfg), cache)
+    readConfigFile(getSystemConfigPath(cfg), cache, config)
 
   if optSkipUserConfigFile notin gGlobalOptions:
-    readConfigFile(getUserConfigPath(cfg), cache)
+    readConfigFile(getUserConfigPath(cfg), cache, config)
 
   var pd = if gProjectPath.len > 0: gProjectPath else: getCurrentDir()
   if optSkipParentConfigFiles notin gGlobalOptions:
     for dir in parentDirs(pd, fromRoot=true, inclusive=false):
-      readConfigFile(dir / cfg, cache)
+      readConfigFile(dir / cfg, cache, config)
 
   if optSkipProjConfigFile notin gGlobalOptions:
-    readConfigFile(pd / cfg, cache)
+    readConfigFile(pd / cfg, cache, config)
 
     if gProjectName.len != 0:
       # new project wide config file:
@@ -251,8 +251,8 @@ proc loadConfigs*(cfg: string; cache: IdentCache) =
         projectConfig = changeFileExt(gProjectFull, "nimrod.cfg")
         if fileExists(projectConfig):
           rawMessage(warnDeprecated, projectConfig)
-      readConfigFile(projectConfig, cache)
+      readConfigFile(projectConfig, cache, config)
 
-proc loadConfigs*(cfg: string) =
+proc loadConfigs*(cfg: string; config: ConfigRef = nil) =
   # for backwards compatibility only.
-  loadConfigs(cfg, newIdentCache())
+  loadConfigs(cfg, newIdentCache(), config)