Merge pull request #132 from retropc/lua_country

[irc/quakenet/newserv.git] / configure

#!/usr/bin/env python3

import sys
import os
import platform
import getopt
import subprocess
import errno
import shlex

LOG = None
VERBOSE = False
REQUIRE_ALL = False

class CheckCallException(Exception):
  pass

# standard line print
def lprint(x):
  print(x)
  LOG.write(x + "\n")

# verbose print
def vprint(x=""):
  if VERBOSE:
    print(x)
  LOG.write(x + "\n")

# immediate (no newline) print
def iprint(x):
  sys.stdout.write(x)
  sys.stdout.flush()
  LOG.write(x)

class IniParser:
  def __init__(self, f):
    self.__d = {}
    sectiondata = None
    for x in f.readlines():
      x = x.replace("\r\n", "").replace("\n", "")
      xs = x.strip()
      if xs == "" or xs.startswith("#"):
        continue

      if x.startswith("[") and x.endswith("]"):
        sectiondata = {}
        keydata = []
        self.__d[x[1:-1]] = (sectiondata, keydata)
        continue

      key, value = x.split("=", 1)
      sectiondata[key] = value
      keydata.append((key, value))

  def has_key(self, key):
    return key in self.__d

  def get(self, key, value=None):
    if key not in self.__d:
      return value
    return self[key]

  def __getitem__(self, key):
    return self.__d[key][0]

  def keys(self, key):
    return self.__d[key][1]

class ConfigureIniParser(IniParser):
  def __init__(self, f):
    super().__init__(f)

    self.modules = {}
    self.buildorder = []
    self.updatemodules(self.keys("modules"))

    self.selectlibs = {}
    for k, v in self.get("selectlibs", {}).items():
      self.selectlibs[k] = v.split()

    self.libs = {}
    for x in self["core"]["libs"].split():
      section = f"lib{x}"
      if "run" in self[section]:
        subsections = self[section]["run"].split(" ")
      else:
        subsections = [section]

      self.libs[x] = []
      for subsection in subsections:
        self.libs[x].append(dict(self[subsection]))

    self.osflags = {}
    if self.has_key("osvars"):
      for k, v in self.keys("osvars"):
        self.osflags.setdefault(k, []).append(v)

    self.options = self["options"]

  def configprint(self):
    vprint("--- config --------------------------------------------")
    for x in dir(self):
      if x.startswith("_"):
        continue
      v = getattr(self, x)
      if not isinstance(v, list) and not isinstance(v, dict):
        continue
      vprint(f"{x!r:50}: {v!r}")
    vprint("--- config --------------------------------------------")

  def updatemodules(self, x, workspace = None):
    for k, v in x:
      if workspace and workspace != ".":
        name = workspace + "/" + k
      else:
        name = k
      self.buildorder.append(name)
      self.modules[name] = v.split()

class MultiConfigureIniParser(ConfigureIniParser):
  def __init__(self, files):
    super().__init__(files[0][1])

    for workspace, file in files[1:]:
      c2 = IniParser(file)
      if c2.has_key("modules"):
        self.updatemodules(c2.keys("modules"), workspace)

      if c2.has_key("options"):
        self.options.update(c2["options"])

      if c2.has_key("osvars"):
        for k, v in c2.keys("osvars"):
          self.osflags.setdefault(k, []).append(v)

def check_call(args):
  vprint(f"invoking: {args!r}")
  p = subprocess.Popen(args, stdin=subprocess.DEVNULL, stdout=subprocess.PIPE, stderr=subprocess.PIPE, encoding="latin-1")
  stdout, stderr = p.communicate()
  if p.returncode != 0:
    raise CheckCallException(f"bad return code: {p.returncode}, stdout: {stdout!r} stderr: {stderr!r}")
  vprint(f"return code: {p.returncode}, stdout: {stdout!r} stderr: {stderr!r}")
  return stdout.split("\n")[0]

def pkgconfig(args):
  return check_call(["pkg-config"] + args)

def check_pkgconfig(d):
  package = d.get("pkgconfig")
  if not package:
    return

  try:
    pkgconfig(["--exists", package])
  except CheckCallException:
    return

  libpath = pkgconfig(["--libs", package])
  incpath = pkgconfig(["--cflags", package])
  return libpath, incpath

def check_exec(d):
  if "libexec" not in d or "incexec" not in d:
    return

  try:
    libpath = check_call(shlex.split(d["libexec"]))
    incpath = check_call(shlex.split(d["incexec"]))
  except FileNotFoundError:
    # already logged
    return

  libspec = d.get("libspec", "{}")
  lib = libspec.replace("{}", libpath)

  incspec = d.get("incspec", "{}")
  inc = incspec.replace("{}", incpath)

  return lib, inc

def librarycheck(libraries):
  def findlibrarypaths(library, defn):
    for x in defn:
      if x.get("alwayspresent"):
        return True

      v = check_pkgconfig(x)
      if v is not None:
        return v
      v = check_exec(x)
      if v is not None:
        return v

  libsfound = []
  output = []

  for k in libraries:
    iprint(f"checking for {k}... ")
    ret = findlibrarypaths(k, libraries[k])
    if not ret:
      lprint("failed")
      continue

    libsfound.append(k)

    if ret is not True:
      lib, inc = ret
      libline = f"LIB{k.upper()}={lib}"
      incline = f"INC{k.upper()}={inc}"
      output.append(libline)
      output.append(incline)

    lprint("ok")
    if ret is not True:
      vprint(f"library path: {libline}")
      vprint(f"include path: {incline}")

  return output, libsfound

def systemcheck(osflags):
  output = []

  iprint("checking for system... ")
  system = platform.system()
  lprint(system)

  iprint("checking for pkg-config... ")
  try:
    pkgconfig(["--version"])
  except FileNotFoundError:
    lprint("not found")
    lprint("pkg-config is required to continue, aborting!")
    sys.exit(1)
  lprint("ok")

  for v in osflags.get(system, []):
    output.append(v)
  return output,

def modulecheck(modules, libsfound, buildorder, selectlibs, overrides):
  defaultselections = {}

  for k, v in selectlibs.items():
    if k in overrides:
      assert overrides[k] in libsfound
      libsfound.append(k)
      defaultselections[k] = overrides[k]
    else:
      for x in v:
        if x in libsfound:
          libsfound.append(k)
          defaultselections[k] = x
          break

  building = set()
  for k, v in modules.items():
    for x in v:
      if x not in libsfound:
        break
    else:
      building.add(k)

  notfound = set(filter(lambda x: not os.path.exists(x), building))

  cantbuild = set(modules) - building
  building = building - notfound

  orderedbuild = []
  for x in buildorder:
    if x in building:
      orderedbuild.append(x)

  build = [f"DIRS={' '.join(orderedbuild)}"]
  return build, orderedbuild, notfound, cantbuild, defaultselections

def writemakefile(inc, out, appendstart=None, appendend=None, silent=False):
  with open(out, "w") as p:
    p.write(f"## AUTOMATICALLY GENERATED -- EDIT {inc} INSTEAD\n\n")
    if appendstart:
      p.write("\n".join(appendstart))
      p.write("\n")

    with open(inc, "r") as f:
      for l in f.readlines():
        p.write(l)

    if appendend:
      p.write("\n".join(appendend))
      p.write("\n")

  if not silent:
    lprint(f"configure: wrote {out}")

def writeconfigh(filename, modules, defaultselections):
  with open(filename, "w") as f:
    f.write("/* AUTOMATICALLY GENERATED -- DO NOT EDIT */\n")

    for x in modules:
      f.write(f"#define HAVE_{x.upper()}\n")
    for k, v in defaultselections.items():
      f.write(f"#define USE_{k.upper()}_{v.upper()}\n")

  lprint(f"configure: wrote {filename}")

def configure(config, selectoverrides, workspaces):
  # figure out any custom OS flags
  flags, = systemcheck(config.osflags)

  # find the libraries/includes we have and their paths
  f, libsfound = librarycheck(config.libs)
  for k, v in selectoverrides.items():
    if not v in libsfound:
      lprint(f"configure: can't set {k} to {v} as {v} was not found.")
      return

  flags = flags + f

  # see which modules we can build
  buildlines, building, notfound, cantbuild, defaultselections = modulecheck(config.modules, libsfound, config.buildorder, config.selectlibs, selectoverrides)

  for k, v in defaultselections.items():
    lprint(f"configure: selected {v} as {k}")
    flags.append(f"LIB{k.upper()}=$(LIB{v.upper()})")
    flags.append(f"INC{k.upper()}=$(INC{v.upper()})")

  writemakefile("build.mk.in", "build.mk", appendend=flags + ["=".join(x) for x in config.options.items()] + ["DIRS=" + " ".join(building), "WORKSPACES=" + " ".join(workspaces)])

  writeconfigh("config.h", libsfound, defaultselections)

  lprint(f"configure: selected: {' '.join(building)}")
  if len(notfound) > 0:
    lprint(f"configure: couldn't find: {' '.join(notfound)}")
    check_require_all()

  if len(cantbuild) > 0:
    lprint(f"configure: can't select: {' '.join(cantbuild)}")
    check_require_all()

def check_require_all():
  if REQUIRE_ALL:
    lprint("configure: require-all selected, so failing")
    sys.exit(1)

validopts = {}

def usage():
  print()
  print(f"  Usage: {sys.argv[0]} [-h] [-v] [options]")
  print()
  print("  Additional options are:")
  for k, v in validopts.items():
    print(f"    --with-{v[0]}=[{'|'.join(v[1])}]")
  print("    -L [additional lib dir]")
  print("    -I [additional include dir]")
  print("    -m [additional module]")
  print("    -R: require everything")
  print("    -v: verbose")

def main():
  global LOG, VERBOSE, REQUIRE_ALL

  files, workspaces = [], []
  for root, _, file_list in os.walk("."):
    if "configure.ini" not in file_list:
      continue

    print(f"found workspace: {root}")
    workspaces.append(root)

    path = os.path.join(root, "configure.ini")
    files.append( (root, open(path, "r")) )

    local_path = os.path.join(root, "configure.ini.local")
    if os.path.exists(local_path):
      files.append( (root, open(local_path, "r")) )

  config = MultiConfigureIniParser(files)

  mopts = []

  for k, v in config.selectlibs.items():
    mopts.append(f"with-{k}=")
    validopts[f"--with-{k}"] = (k, v)

  try:
    opts, args = getopt.getopt(sys.argv[1:], "hvcI:L:m:R", mopts)
  except getopt.GetoptError as err:
    print(str(err))
    usage()
    sys.exit(1)

  overrides = {}
  libs = []
  includes = []
  modules = []

  for o, a in opts:
    if o in validopts:
      v = validopts[o]
      if not a in v[1]:
        usage()
        return
      overrides[v[0]] = a
    elif o == "-h":
      usage()
      return
    elif o == "-v":
      VERBOSE = True
    elif o == "-R":
      REQUIRE_ALL = True
    elif o == "-L":
      libs.append(a)
    elif o == "-I":
      includes.append(a)
    elif o == "-m":
      modules.append(a)
    else:
      raise Exception(f"unknown option: {o!r}")

  with open(".configure.log", "w") as LOG:
    vprint(f"invoked as: {sys.argv!r}")
    config.updatemodules([(x, "") for x in modules])
    config.configprint()

    configure(config, overrides, workspaces)

if __name__ == "__main__":
  main()