Add -C option

1 files changed, 162 insertions, 144 deletions

diff --git a/src/main.nim b/src/main.nim
index 86066c28..47e00959 100644
--- a/src/main.nim
+++ b/src/main.nim
@@ -18,182 +18,200 @@ when defined(profile):
 import config/config
 import io/serversocket
 import local/client
-import types/opt
 import utils/twtstr
 
 import chakasu/charset
 
-let conf = readConfig()
-set_cjk_ambiguous(conf.display.double_width_ambiguous)
-let params = commandLineParams()
+proc main() =
+  let params = commandLineParams()
 
-proc version(long: static bool = false): string =
-  result = "Chawan browser v0.1 "
-  when defined(debug):
-    result &= "(debug)"
-  else:
-    result &= "(release)"
+  proc version(long: static bool = false): string =
+    result = "Chawan browser v0.1 "
+    when defined(debug):
+      result &= "(debug)"
+    else:
+      result &= "(release)"
 
-proc help(i: int) =
-  let s = version() & """
+  proc help(i: int) =
+    let s = version() & """
 
 Usage: cha [options] [URL(s) or file(s)...]
 Options:
     --                          Interpret all following arguments as URLs
-    -d, --dump                  Print page to stdout
     -c, --css <stylesheet>      Pass stylesheet (e.g. -c 'a{color: blue}')
+    -d, --dump                  Print page to stdout
+    -h, --help                  Print this usage message
     -o, --opt <config>          Pass config options (e.g. -o 'page.q="quit()"')
-    -T, --type <type>           Specify content mime type
+    -r, --run <script/file>     Run passed script or file
+    -v, --version               Print version information
+    -C, --config <file>         Override config path
     -I, --input-charset <enc>   Specify document charset
-    -O, --display-charset <enc> Specify display charset
     -M, --monochrome            Set color-mode to 'monochrome'
-    -V, --visual                Visual startup mode
-    -r, --run <script/file>     Run passed script or file
-    -h, --help                  Print this usage message
-    -v, --version               Print version information"""
-  if i == 0:
-    stdout.write(s & '\n')
-  else:
-    stderr.write(s & '\n')
-  quit(i)
-
-var i = 0
-var ctype = none(string)
-var cs = CHARSET_UNKNOWN
-var pages: seq[string]
-var dump = false
-var visual = false
-var escape_all = false
-
-while i < params.len:
-  let param = params[i]
-
-  if escape_all: # after --
-    pages.add(param)
-    inc i
-    continue
+    -O, --display-charset <enc> Specify display charset
+    -T, --type <type>           Specify content mime type
+    -V, --visual                Visual startup mode"""
 
-  proc getnext(): string =
-    inc i
-    if i < params.len:
-      return params[i]
-    help(1)
+    if i == 0:
+      stdout.write(s & '\n')
+    else:
+      stderr.write(s & '\n')
+    quit(i)
+
+  var ctype = none(string)
+  var cs = CHARSET_UNKNOWN
+  var pages: seq[string]
+  var dump = false
+  var visual = false
+  var escape_all = false
+  var opts: seq[string]
+  var stylesheet = ""
+  var configPath = none(string)
+
+  var i = 0
+  while i < params.len:
+    let param = params[i]
+
+    if escape_all: # after --
+      pages.add(param)
+      inc i
+      continue
 
-  proc pversion() =
-    echo version(true)
-    quit(0)
+    proc getnext(): string =
+      inc i
+      if i < params.len:
+        return params[i]
+      help(1)
 
-  proc pmonochrome() =
-    conf.display.colormode.ok(MONOCHROME)
+    proc pconfig() =
+      configPath = some(getnext())
 
-  proc pvisual() =
-    visual = true
+    proc pversion() =
+      echo version(true)
+      quit(0)
 
-  proc ptype() =
-    ctype = some(getnext())
+    proc pmonochrome() =
+      opts.add("display.color-mode = monochrome")
 
-  proc pgetCharset(): Charset =
-    let s = getnext()
-    let cs = getCharset(s)
-    if cs == CHARSET_UNKNOWN:
-      stderr.write("Unknown charset " & s & "\n")
-      quit(1)
-    return cs
+    proc pvisual() =
+      visual = true
 
-  proc pinput_charset() =
-    cs = pgetCharset()
+    proc ptype() =
+      ctype = some(getnext())
 
-  proc poutput_charset() =
-    conf.encoding.display_charset.ok(pgetCharset())
+    proc pgetCharset(): Charset =
+      let s = getnext()
+      let cs = getCharset(s)
+      if cs == CHARSET_UNKNOWN:
+        stderr.write("Unknown charset " & s & "\n")
+        quit(1)
+      return cs
 
-  proc pdump() =
-    dump = true
+    proc pinput_charset() =
+      cs = pgetCharset()
 
-  proc pcss() =
-    conf.css.stylesheet &= getnext()
+    proc poutput_charset() =
+      opts.add("encoding.display-charset = '" & $pgetCharset() & "'")
 
-  proc popt() =
-    conf.parseConfig(getCurrentDir(), getnext(), laxnames = true)
+    proc pdump() =
+      dump = true
 
-  proc phelp() =
-    help(0)
+    proc pcss() =
+      stylesheet &= getnext()
 
-  proc prun() =
-    conf.start.startup_script = getnext()
-    conf.start.headless = true
-    dump = true
+    proc popt() =
+      opts.add(getnext())
 
-  if param.len == 0:
-    inc i
-    continue
+    proc phelp() =
+      help(0)
 
-  const NeedsNextParam = {'T', 'I', 'O', 'c', 'o', 'r'}
+    proc prun() =
+      let script = dqEscape(getnext())
+      opts.add("start.startup-script = \"\"\"" & script & "\"\"\"")
+      opts.add("start.headless = true")
+      dump = true
 
-  if param[0] == '-':
-    if param.len == 1:
-      # If param == "-", i.e. it is a single dash, then ignore it.
-      # (Some programs use single-dash to read from stdin, but we do that
-      # automatically when stdin is not a tty. So ignoring it entirely
-      # is probably for the best.)
+    if param.len == 0:
       inc i
       continue
-    if param[1] != '-':
-      for j in 1 ..< param.len:
-        if j != param.high and param[j] in NeedsNextParam:
-          # expecting next parameter, but not the last char...
-          help(1)
-        case param[j]
-        of 'v': pversion()
-        of 'M': pmonochrome()
-        of 'V': pvisual()
-        of 'T': ptype()
-        of 'I': pinput_charset()
-        of 'O': poutput_charset()
-        of 'd': pdump()
-        of 'c': pcss()
-        of 'o': popt()
-        of 'h': phelp()
-        of 'r': prun()
+
+    const NeedsNextParam = {'C', 'I', 'O', 'T', 'c', 'o', 'r'}
+
+    if param[0] == '-':
+      if param.len == 1:
+        # If param == "-", i.e. it is a single dash, then ignore it.
+        # (Some programs use single-dash to read from stdin, but we do that
+        # automatically when stdin is not a tty. So ignoring it entirely
+        # is probably for the best.)
+        inc i
+        continue
+      if param[1] != '-':
+        for j in 1 ..< param.len:
+          if j != param.high and param[j] in NeedsNextParam:
+            # expecting next parameter, but not the last char...
+            help(1)
+          case param[j]
+          of 'C': pconfig()
+          of 'I': pinput_charset()
+          of 'M': pmonochrome()
+          of 'O': poutput_charset()
+          of 'T': ptype()
+          of 'V': pvisual()
+          of 'c': pcss()
+          of 'd': pdump()
+          of 'h': phelp()
+          of 'o': popt()
+          of 'r': prun()
+          of 'v': pversion()
+          else: help(1)
+      else:
+        case param
+        of "--config": pconfig()
+        of "--input-charset": pinput_charset()
+        of "--monochrome": pmonochrome()
+        of "--output-charset": poutput_charset()
+        of "--type": ptype()
+        of "--visual": pvisual()
+        of "--css": pcss()
+        of "--dump": pdump()
+        of "--help": phelp()
+        of "--opt": popt()
+        of "--run": prun()
+        of "--version": pversion()
+        of "--": escape_all = true
         else: help(1)
     else:
-      case param
-      of "--version": pversion()
-      of "--monochrome": pmonochrome()
-      of "--visual": pvisual()
-      of "--type": ptype()
-      of "--input-charset": pinput_charset()
-      of "--output-charset": poutput_charset()
-      of "--dump": pdump()
-      of "--css": pcss()
-      of "--opt": popt()
-      of "--help": phelp()
-      of "--run": prun()
-      of "--": escape_all = true
-      else: help(1)
-  else:
-    pages.add(param)
-  inc i
-
-if pages.len == 0 and stdin.isatty():
-  if visual:
-    pages.add(conf.start.visual_home)
-  else:
-    let http = getEnv("HTTP_HOME")
-    if http != "": pages.add(http)
+      pages.add(param)
+    inc i
+
+  let config = readConfig(configPath)
+  for opt in opts:
+    config.parseConfig(getCurrentDir(), opt, laxnames = true)
+  config.css.stylesheet &= stylesheet
+
+  set_cjk_ambiguous(config.display.double_width_ambiguous)
+
+  if pages.len == 0 and stdin.isatty():
+    if visual:
+      pages.add(config.start.visual_home)
     else:
-      let www = getEnv("WWW_HOME")
-      if www != "": pages.add(www)
-
-if pages.len == 0 and not conf.start.headless:
-  if stdin.isatty:
-    help(1)
-
-forks.loadForkServerConfig(conf)
-SocketDirectory = conf.external.tmpdir
-
-let c = newClient(conf, forks, getpid())
-try:
-  c.launchClient(pages, ctype, cs, dump)
-except CatchableError:
-  c.flushConsole()
-  raise
+      let http = getEnv("HTTP_HOME")
+      if http != "": pages.add(http)
+      else:
+        let www = getEnv("WWW_HOME")
+        if www != "": pages.add(www)
+
+  if pages.len == 0 and not config.start.headless:
+    if stdin.isatty:
+      help(1)
+
+  forks.loadForkServerConfig(config)
+  SocketDirectory = config.external.tmpdir
+
+  let c = newClient(config, forks, getpid())
+  try:
+    c.launchClient(pages, ctype, cs, dump)
+  except CatchableError:
+    c.flushConsole()
+    raise
+
+main()