#
# gen_base.py -- infrastructure for generating makefiles, dependencies, etc.
#

import os, sys
import string, glob, re
import fileinput
import ConfigParser


__all__ = ['MakefileGenerator', 'MsvcProjectGenerator']


class _GeneratorBase:

  #
  # Derived classes should define a class attribute named _extension_map.
  # This attribute should be a dictionary of the form:
  #     { (target-type, file-type): file-extension ...}
  #
  # where: target-type is 'exe', 'lib', ...
  #        file-type is 'target', 'object', ...
  #

  def __init__(self, fname):
    self.parser = ConfigParser.ConfigParser(_cfg_defaults)
    self.parser.read(fname)

    self.targets = { }
    self.includes = [ ]
    self.install = { }                       # install area name -> targets
    self.test_progs = [ ]
    self.test_deps = [ ]
    self.fs_test_progs = [ ]
    self.fs_test_deps = [ ]
    self.file_deps = [ ]
    self.target_dirs = { }
    self.manpages = [ ]
    self.infopages = [ ]

    # PASS 1: collect the targets and some basic info
    errors = 0
    self.target_names = _filter_targets(self.parser.sections())
    for target in self.target_names:
      try:
        target_ob = _Target(target,
                            self.parser.get(target, 'path'),
                            self.parser.get(target, 'install'),
                            self.parser.get(target, 'type'),
                            self._extension_map)
      except GenError, e:
        print e
        errors = 1
        continue

      self.targets[target] = target_ob

      itype = target_ob.install
      if self.install.has_key(itype):
        self.install[itype].append(target_ob)
      else:
        self.install[itype] = [ target_ob ]

      self.target_dirs[target_ob.path] = None

    if errors:
      raise GenError('Target generation failed.')


class MsvcProjectGenerator(_GeneratorBase):

  _extension_map = {
    ('exe', 'target'): '.exe',
    ('exe', 'object'): '.obj',
    ('lib', 'target'): '.dll',
    ('lib', 'object'): '.obj',
    }

  def __init__(self, fname, oname):
    _GeneratorBase.__init__(self, fname)

  def write(self):
    raise NotImplementedError


class MakefileGenerator(_GeneratorBase):

  _extension_map = {
    ('exe', 'target'): '',
    ('exe', 'object'): '.o',
    ('lib', 'target'): '.la',
    ('lib', 'object'): '.lo',
    }

  def __init__(self, fname, oname):
    _GeneratorBase.__init__(self, fname)

    self.ofile = open(oname, 'w')
    self.ofile.write('# DO NOT EDIT -- AUTOMATICALLY GENERATED\n\n')

  def write(self):
    errors = 0
    for target in self.target_names:
      target_ob = self.targets[target]

      path = target_ob.path
      bldtype = target_ob.type
      objext = target_ob.objext

      tpath = target_ob.output
      tfile = os.path.basename(tpath)

      if target_ob.install == 'test' and bldtype == 'exe':
        self.test_deps.append(tpath)
        if self.parser.get(target, 'testing') != 'skip':
          self.test_progs.append(tpath)

      if target_ob.install == 'fs-test' and bldtype == 'exe':
        self.fs_test_deps.append(tpath)
        if self.parser.get(target, 'testing') != 'skip':
          self.fs_test_progs.append(tpath)

      s_errors = target_ob.find_sources(self.parser.get(target, 'sources'))
      errors = errors or s_errors

      objects = [ ]
      for src in target_ob.sources:
        if src[-2:] == '.c':
          objname = src[:-2] + objext
          objects.append(objname)
          self.file_deps.append((src, objname))
        else:
          print 'ERROR: unknown file extension on', src
          errors = 1

      retreat = _retreat_dots(path)
      libs = [ ]
      deps = [ ]
      for lib in string.split(self.parser.get(target, 'libs')):
        if lib in self.target_names:
          tlib = self.targets[lib]
          target_ob.deps.append(tlib)
          deps.append(tlib.output)

          # link in the library by simply referring to the .la file
          ### hmm. use join() for retreat + ... ?
          libs.append(retreat + os.path.join(tlib.path, lib + '.la'))
        else:
          # something we don't know, so just include it directly
          libs.append(lib)

      for man in string.split(self.parser.get(target, 'manpages')):
        self.manpages.append(man)

      for info in string.split(self.parser.get(target, 'infopages')):
        self.infopages.append(info)

      targ_varname = string.replace(target, '-', '_')
      ldflags = self.parser.get(target, 'link-flags')
      add_deps = self.parser.get(target, 'add-deps')
      objnames = string.join(map(os.path.basename, objects))
      self.ofile.write(
        '%s_DEPS = %s %s\n'
        '%s_OBJECTS = %s\n'
        '%s: $(%s_DEPS)\n'
        '\tcd %s && $(LINK) -o %s %s $(%s_OBJECTS) %s $(LIBS)\n\n'
        % (targ_varname, string.join(objects + deps), add_deps,
           targ_varname, objnames,
           tpath, targ_varname,
           path, tfile, ldflags, targ_varname, string.join(libs))
        )

      custom = self.parser.get(target, 'custom')
      if custom == 'apache-mod':
        # special build, needing Apache includes
        self.ofile.write('# build these special -- use APACHE_INCLUDES\n')
        for src in target_ob.sources:
          if src[-2:] == '.c':
            self.ofile.write('%s%s: %s\n\t$(COMPILE_APACHE_MOD)\n'
                             % (src[:-2], objext, src))
        self.ofile.write('\n')
      elif custom == 'swig-py':
        self.ofile.write('# build this with -DSWIGPYTHON\n')
        for src in target_ob.sources:
          if src[-2:] == '.c':
            self.ofile.write('%s%s: %s\n\t$(COMPILE_SWIG_PY)\n'
                             % (src[:-2], objext, src))
        self.ofile.write('\n')

    for g_name, g_targets in self.install.items():
      self.target_names = [ ]
      for i in g_targets:
        self.target_names.append(i.output)

      self.ofile.write('%s: %s\n\n' % (g_name, string.join(self.target_names)))

    cfiles = [ ]
    for target in self.targets.values():
      # .la files are handled by the standard 'clean' rule; clean all the
      # other targets
      if target.output[-3:] != '.la':
        cfiles.append(target.output)
    self.ofile.write('CLEAN_FILES = %s\n\n' % string.join(cfiles))

    for area, inst_targets in self.install.items():
      # get the output files for these targets, sorted in dependency order
      files = _sorted_files(inst_targets)

      if area == 'apache-mod':
        self.ofile.write('install-mods-shared: %s\n' % (string.join(files),))
        la_tweaked = { }
        for file in files:
          # cd to dirname before install to work around libtool 1.4.2 bug.
          dirname, fname = os.path.split(file)
          base, ext = os.path.splitext(fname)
          name = string.replace(base, 'libmod_', '')
          self.ofile.write('\tcd %s ; $(INSTALL_MOD_SHARED) -n %s %s\n'
                           % (dirname, name, fname))
          if ext == '.la':
            la_tweaked[file + '-a'] = None

        for t in inst_targets:
          for dep in t.deps:
            bt = dep.output
            if bt[-3:] == '.la':
              la_tweaked[bt + '-a'] = None
        la_tweaked = la_tweaked.keys()

        s_files, s_errors = _collect_paths(self.parser.get('static-apache',
                                                           'paths'))
        errors = errors or s_errors

        # Construct a .libs directory within the Apache area and populate it
        # with the appropriate files. Also drop the .la file in the target dir.
        self.ofile.write('\ninstall-mods-static: %s\n'
                         '\t$(MKDIR) %s\n'
                         % (string.join(la_tweaked + s_files),
                            os.path.join('$(APACHE_TARGET)', '.libs')))
        for file in la_tweaked:
          dirname, fname = os.path.split(file)
          base = os.path.splitext(fname)[0]
          self.ofile.write('\t$(INSTALL_MOD_STATIC) %s %s\n'
                           '\t$(INSTALL_MOD_STATIC) %s %s\n'
                           % (os.path.join(dirname, '.libs', base + '.a'),
                              os.path.join('$(APACHE_TARGET)',
                                           '.libs',
                                           base + '.a'),
                              file,
                              os.path.join('$(APACHE_TARGET)', base + '.la')))

        # copy the other files to the target dir
        for file in s_files:
          self.ofile.write('\t$(INSTALL_MOD_STATIC) %s %s\n'
                           % (file, os.path.join('$(APACHE_TARGET)',
                                                 os.path.basename(file))))
        self.ofile.write('\n')

      elif area != 'test' and area != 'fs-test':
        area_var = string.replace(area, '-', '_')
        self.ofile.write('install-%s: %s\n'
                         '\t$(MKDIR) $(%sdir)\n'
                         % (area, string.join(files), area_var))
        for file in files:
          # cd to dirname before install to work around libtool 1.4.2 bug.
          dirname, fname = os.path.split(file)
          self.ofile.write('\tcd %s ; $(INSTALL_%s) %s %s\n'
                           % (dirname,
                              string.upper(area_var),
                              fname,
                              os.path.join('$(%sdir)' % area_var, fname)))
        self.ofile.write('\n')

      # generate .dsp files for each target
      #for t in inst_targets:
      #  t.write_dsp()
      #  pass

    self.includes, i_errors = _collect_paths(self.parser.get('includes',
                                                             'paths'))
    errors = errors or i_errors

    self.ofile.write('install-include: %s\n'
                     '\t$(MKDIR) $(includedir)\n'
                     % (string.join(self.includes),))
    for file in self.includes:
      self.ofile.write('\t$(INSTALL_INCLUDE) %s %s\n'
                       % (os.path.join('$(top_srcdir)', file),
                          os.path.join('$(includedir)',
                                       os.path.basename(file))))

    self.ofile.write('\n# handy shortcut targets\n')
    for name, target in self.targets.items():
      self.ofile.write('%s: %s\n' % (name, target.output))
    self.ofile.write('\n')

    scripts, s_errors = _collect_paths(self.parser.get('test-scripts',
                                                       'paths'))
    errors = errors or s_errors

    fs_scripts, fs_errors = _collect_paths(self.parser.get('fs-test-scripts',
                                                           'paths'))
    errors = errors or fs_errors

    # get all the test scripts' directories
    script_dirs = map(os.path.dirname, scripts + fs_scripts)

    # remove duplicate directories
    build_dirs = self.target_dirs.copy()
    for d in script_dirs:
      build_dirs[d] = None

    self.ofile.write('BUILD_DIRS = %s\n' % string.join(build_dirs.keys()))

    self.ofile.write('FS_TEST_DEPS = %s\n\n' %
                     string.join(self.fs_test_deps + fs_scripts))
    self.ofile.write('FS_TEST_PROGRAMS = %s\n\n' %
                     string.join(self.fs_test_progs + fs_scripts))
    self.ofile.write('TEST_DEPS = %s\n\n' %
                     string.join(self.test_deps + scripts))
    self.ofile.write('TEST_PROGRAMS = %s\n\n' %
                     string.join(self.test_progs + scripts))

    self.ofile.write('MANPAGES = %s\n\n' % string.join(self.manpages))
    self.ofile.write('INFOPAGES = %s\n\n' % string.join(self.infopages))

    if errors:
      raise GenError("Makefile generation failed.")


  def write_depends(self):
    #
    # Find all the available headers and what they depend upon. the
    # include_deps is a dictionary mapping a short header name to a tuple
    # of the full path to the header and a dictionary of dependent header
    # names (short) mapping to None.
    #
    # Example:
    #   { 'short.h' : ('/path/to/short.h',
    #                  { 'other.h' : None, 'foo.h' : None }) }
    #
    # Note that this structure does not allow for similarly named headers
    # in per-project directories. SVN doesn't have this at this time, so
    # this structure works quite fine. (the alternative would be to use
    # the full pathname for the key, but that is actually a bit harder to
    # work with since we only see short names when scanning, and keeping
    # a second variable around for mapping the short to long names is more
    # than I cared to do right now)
    #
    include_deps = _create_include_deps(self.includes)
    for d in self.target_dirs.keys():
      hdrs = glob.glob(os.path.join(d, '*.h'))
      if hdrs:
        more_deps = _create_include_deps(hdrs, include_deps)
        include_deps.update(more_deps)

    for src, objname in self.file_deps:
      hdrs = [ ]
      for short in _find_includes(src, include_deps):
        hdrs.append(include_deps[short][0])
      self.ofile.write('%s: %s %s\n' % (objname, src, string.join(hdrs)))


class _Target:
  def __init__(self, name, path, install, type, extmap):
    self.name = name
    self.deps = [ ]	# dependencies (list of other Target objects)
    self.path = path
    self.type = type

    if type == 'exe':
      if not install:
        install = 'bin'
    elif type == 'lib':
      if not install:
        install = 'lib'
    elif type == 'doc':
      pass
    else:
      raise GenError('ERROR: unknown build type: ' + type)

    if type == 'exe' or type == 'lib':
      tfile = name + extmap[(type, 'target')]
      self.objext = extmap[(type, 'object')]

    self.install = install
    self.output = os.path.join(path, tfile)

  def find_sources(self, patterns):
    if not patterns:
      patterns = _default_sources[self.type]
    self.sources, errors = _collect_paths(patterns, self.path)
    self.sources.sort()
    return errors

  def write_dsp(self):
    if self.type == 'exe':
      template = open('build/win32/exe-template', 'rb').read()
    else:
      template = open('build/win32/dll-template', 'rb').read()

    dsp = string.replace(template, '@NAME@', self.name)

    cfiles = [ ]
    for src in self.sources:
      cfiles.append('# Begin Source File\x0d\x0a'
                    '\x0d\x0a'
                    'SOURCE=.\\%s\x0d\x0a'
                    '# End Source File\x0d\x0a' % os.path.basename(src))
    dsp = string.replace(dsp, '@CFILES@', string.join(cfiles, ''))

    dsp = string.replace(dsp, '@HFILES@', '')

    fname = os.path.join(self.path, self.name + '.dsp-test')
    open(fname, 'wb').write(dsp)

class GenError(Exception):
  pass

_cfg_defaults = {
  'sources' : '',
  'link-flags' : '',
  'libs' : '',
  'manpages' : '',
  'infopages' : '',
  'custom' : '',
  'install' : '',
  'testing' : '',
  'add-deps' : '',
  }

_default_sources = {
  'lib' : '*.c',
  'exe' : '*.c',
  'doc' : '*.texi',
  }

_predef_sections = [
  'includes',
  'static-apache',
  'test-scripts',
  'fs-test-scripts',
  ]

def _filter_targets(t):
  t = t[:]
  for s in _predef_sections:
    if s in t:
      t.remove(s)
  return t

def _collect_paths(pats, path=None):
  errors = 0
  result = [ ]
  for pat in string.split(pats):
    if path:
      pat = os.path.join(path, pat)
    files = glob.glob(pat)
    if not files:
      print 'ERROR:', pat, 'not found.'
      errors = 1
      continue
    result.extend(files)
  return result, errors

def _retreat_dots(path):
  "Given a relative directory, return ../ paths to retreat to the origin."
  parts = string.split(path, os.sep)
  return (os.pardir + os.sep) * len(parts)

def _find_includes(fname, include_deps):
  hdrs = _scan_for_includes(fname, include_deps.keys())
  return _include_closure(hdrs, include_deps).keys()

def _create_include_deps(includes, prev_deps={}):
  shorts = map(os.path.basename, includes)

  # limit intra-header dependencies to just these headers, and what we
  # may have found before
  limit = shorts + prev_deps.keys()

  deps = prev_deps.copy()
  for inc in includes:
    short = os.path.basename(inc)
    deps[short] = (inc, _scan_for_includes(inc, limit))

  # keep recomputing closures until we see no more changes
  while 1:
    changes = 0
    for short in shorts:
      old = deps[short]
      deps[short] = (old[0], _include_closure(old[1], deps))
      if not changes:
        ok = old[1].keys()
        ok.sort()
        nk = deps[short][1].keys()
        nk.sort()
        changes = ok != nk
    if not changes:
      return deps

def _include_closure(hdrs, deps):
  new = hdrs.copy()
  for h in hdrs.keys():
    new.update(deps[h][1])
  return new

_re_include = re.compile(r'^#\s*include\s*[<"]([^<"]+)[>"]')
def _scan_for_includes(fname, limit):
  "Return a dictionary of headers found (fnames as keys, None as values)."
  # note: we don't worry about duplicates in the return list
  hdrs = { }
  for line in fileinput.input(fname):
    match = _re_include.match(line)
    if match:
      h = match.group(1)
      if h in limit:
        hdrs[match.group(1)] = None
  return hdrs

def _sorted_files(targets):
  "Given a list of targets, sort them based on their dependencies."

  # we're going to just go with a naive algorithm here. these lists are
  # going to be so short, that we can use O(n^2) or whatever this is.

  # first we need our own copy of the target list since we're going to
  # munge it.
  targets = targets[:]

  # the output list of the targets' files
  files = [ ]

  # loop while we have targets remaining:
  while targets:
    # find a target that has no dependencies in our current targets list.
    for t in targets:
      for d in t.deps:
        if d in targets:
          break
      else:
        # no dependencies found in the targets list. this is a good "base"
        # to add to the files list now.
        files.append(t.output)

        # don't consider this target any more
        targets.remove(t)

        # break out of search through targets
        break
    else:
      # we went through the entire target list and everything had at least
      # one dependency on another target. thus, we have a circular dependency
      # tree. somebody messed up the .conf file, or the app truly does have
      # a loop (and if so, they're screwed; libtool can't relink a lib at
      # install time if the dependent libs haven't been installed yet)
      raise CircularDependencies()

  return files

class CircularDependencies(Exception):
  pass