Example #1
0
class Generator(object):
    """Base class for generators.

  This class provides a mechanism for adding new generator objects to the IDL
  driver.  To use this class override the GenerateRelease and GenerateRange
  members, and instantiate one copy of the class in the same module which
  defines it to register the generator.  After the AST is generated, call the
  static Run member which will check every registered generator to see which
  ones have been enabled through command-line options.  To enable a generator
  use the switches:
    --<sname> : To enable with defaults
    --<sname>_opt=<XXX,YYY=y> : To enable with generator specific options.

  NOTE:  Generators still have access to global options
  """
    def __init__(self, name, sname, desc):
        self.name = name
        self.run_switch = Option(sname, desc)
        self.opt_switch = Option(sname + '_opt',
                                 'Options for %s.' % sname,
                                 default='')
        GeneratorList.append(self)
        self.errors = 0
        self.skip_list = []

    def Error(self, msg):
        ErrOut.Log('Error %s : %s' % (self.name, msg))
        self.errors += 1

    def GetRunOptions(self):
        options = {}
        option_list = self.opt_switch.Get()
        if option_list:
            option_list = option_list.split(',')
            for opt in option_list:
                offs = opt.find('=')
                if offs > 0:
                    options[opt[:offs]] = opt[offs + 1:]
                else:
                    options[opt] = True
            return options
        if self.run_switch.Get():
            return options
        return None

    def Generate(self, ast, options):
        self.errors = 0

        rangestr = GetOption('range')
        releasestr = GetOption('release')

        print "Found releases: %s" % ast.releases

        # Generate list of files to ignore due to errors
        for filenode in ast.GetListOf('File'):
            # If this file has errors, skip it
            if filenode.GetProperty('ERRORS') > 0:
                self.skip_list.append(filenode)
                continue

        # Check for a range option which over-rides a release option
        if not releasestr and rangestr:
            range_list = rangestr.split(',')
            if len(range_list) != 2:
                self.Error('Failed to generate for %s, incorrect range: "%s"' %
                           (self.name, rangestr))
            else:
                vmin = range_list[0]
                vmax = range_list[1]

                # Generate 'start' and 'end' represent first and last found.
                if vmin == 'start':
                    vmin = ast.releases[0]
                if vmax == 'end':
                    vmax = ast.releases[-1]

                vmin = ast.releases.index(vmin)
                vmax = ast.releases.index(vmax) + 1
                releases = ast.releases[vmin:vmax]
                InfoOut.Log('Generate range %s of %s.' % (rangestr, self.name))
                ret = self.GenerateRange(ast, releases, options)
                if ret < 0:
                    self.Error('Failed to generate range %s : %s.' %
                               (vmin, vmax))
                else:
                    InfoOut.Log('%s wrote %d files.' % (self.name, ret))
        # Otherwise this should be a single release generation
        else:
            if releasestr == 'start':
                releasestr = ast.releases[0]
            if releasestr == 'end':
                releasestr = ast.releases[-1]

            if releasestr > ast.releases[-1]:
                InfoOut.Log(
                    'There is no unique release for %s, using last release.' %
                    releasestr)
                releasestr = ast.releases[-1]

            if releasestr not in ast.releases:
                self.Error('Release %s not in [%s].' %
                           (releasestr, ', '.join(ast.releases)))

            if releasestr:
                InfoOut.Log('Generate release %s of %s.' %
                            (releasestr, self.name))
                ret = self.GenerateRelease(ast, releasestr, options)
                if ret < 0:
                    self.Error('Failed to generate release %s.' % releasestr)
                else:
                    InfoOut.Log('%s wrote %d files.' % (self.name, ret))

            else:
                self.Error('No range or release specified for %s.' %
                           releasestr)
        return self.errors

    def GenerateRelease(self, ast, release, options):
        __pychecker__ = 'unusednames=ast,release,options'
        self.Error("Undefined release generator.")
        return 0

    def GenerateRange(self, ast, releases, options):
        __pychecker__ = 'unusednames=ast,releases,options'
        self.Error("Undefined range generator.")
        return 0

    @staticmethod
    def Run(ast):
        fail_count = 0

        # Check all registered generators if they should run.
        for gen in GeneratorList:
            options = gen.GetRunOptions()
            if options is not None:
                if gen.Generate(ast, options):
                    fail_count += 1
        return fail_count
Example #2
0
class Generator(object):
  def __init__(self, name, sname, desc):
    self.name = name
    self.run_switch = Option(sname, desc)
    self.opt_switch = Option(sname + '_opt', 'Options for %s.' % sname,
                             default='')
    GeneratorList.append(self)
    self.errors = 0
    self.skip_list = []

  def Error(self, msg):
    ErrOut.Log('Error %s : %s' % (self.name, msg))
    self.errors += 1

  def GetRunOptions(self):
    options = {}
    option_list = self.opt_switch.Get()
    if option_list:
      option_list = option_list.split(',')
      for opt in option_list:
        offs = opt.find('=')
        if offs > 0:
          options[opt[:offs]] = opt[offs+1:]
        else:
          options[opt] = True
      return options
    if self.run_switch.Get():
      return options
    return None

  def Generate(self, ast, options):
    self.errors = 0

    rangestr = GetOption('range')
    releasestr = GetOption('release')

    print "Found releases: %s" % ast.releases

    # Generate list of files to ignore due to errors
    for filenode in ast.GetListOf('File'):
      # If this file has errors, skip it
      if filenode.GetProperty('ERRORS') > 0:
        self.skip_list.append(filenode)
        continue

    # Check for a range option which over-rides a release option
    if not releasestr and rangestr:
      range_list = rangestr.split(',')
      if len(range_list) != 2:
        self.Error('Failed to generate for %s, incorrect range: "%s"' %
                   (self.name, rangestr))
      else:
        vmin = range_list[0]
        vmax = range_list[1]

        # Generate 'start' and 'end' represent first and last found.
        if vmin == 'start':
            vmin = ast.releases[0]
        if vmax == 'end':
            vmax = ast.releases[-1]

        vmin = ast.releases.index(vmin)
        vmax = ast.releases.index(vmax) + 1
        releases = ast.releases[vmin:vmax]
        InfoOut.Log('Generate range %s of %s.' % (rangestr, self.name))
        ret = self.GenerateRange(ast, releases, options)
        if ret < 0:
          self.Error('Failed to generate range %s : %s.' %(vmin, vmax))
        else:
          InfoOut.Log('%s wrote %d files.' % (self.name, ret))
    # Otherwise this should be a single release generation
    else:
      if releasestr == 'start':
        releasestr = ast.releases[0]
      if releasestr == 'end':
        releasestr = ast.releases[-1]
      if releasestr:
        InfoOut.Log('Generate release %s of %s.' % (releasestr, self.name))
        ret = self.GenerateRelease(ast, releasestr, options)
        if ret < 0:
          self.Error('Failed to generate release %s.' % releasestr)
        else:
          InfoOut.Log('%s wrote %d files.' % (self.name, ret))

      else:
        self.Error('No range or release specified for %s.' % releasestr)
    return self.errors

  def GenerateRelease(self, ast, release, options):
    __pychecker__ = 'unusednames=ast,release,options'
    self.Error("Undefined release generator.")
    return 0

  def GenerateRange(self, ast, releases, options):
    __pychecker__ = 'unusednames=ast,releases,options'
    self.Error("Undefined range generator.")
    return 0

  @staticmethod
  def Run(ast):
    fail_count = 0

    # Check all registered generators if they should run.
    for gen in GeneratorList:
      options = gen.GetRunOptions()
      if options is not None:
        if gen.Generate(ast, options):
          fail_count += 1
    return fail_count