ppapi/generators/idl_release.py

   1 #!/usr/bin/env python
   2 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5
   6 """
   7 IDLRelease for PPAPI
   8
   9 This file defines the behavior of the AST namespace which allows for resolving
  10 a symbol as one or more AST nodes given a Release or range of Releases.
  11 """
  12
  13 import sys
  14
  15 from idl_log import ErrOut, InfoOut, WarnOut
  16 from idl_option import GetOption, Option, ParseOptions
  17
  18 Option('release_debug', 'Debug Release data')
  19 Option('wgap', 'Ignore Release gap warning')
  20
  21
  22 #
  23 # Module level functions and data used for testing.
  24 #
  25 error = None
  26 warning = None
  27 def ReportReleaseError(msg):
  28   global error
  29   error = msg
  30
  31 def ReportReleaseWarning(msg):
  32   global warning
  33   warning = msg
  34
  35 def ReportClear():
  36   global error, warning
  37   error = None
  38   warning = None
  39
  40 #
  41 # IDLRelease
  42 #
  43 # IDLRelease is an object which stores the association of a given symbol
  44 # name, with an AST node for a range of Releases for that object.
  45 #
  46 # A vmin value of None indicates that the object begins at the earliest
  47 # available Release number.  The value of vmin is always inclusive.
  48
  49 # A vmax value of None indicates that the object is never deprecated, so
  50 # it exists until it is overloaded or until the latest available Release.
  51 # The value of vmax is always exclusive, representing the first Release
  52 # on which the object is no longer valid.
  53 class IDLRelease(object):
  54   def __init__(self, rmin, rmax):
  55     self.rmin = rmin
  56     self.rmax = rmax
  57
  58   def __str__(self):
  59     if not self.rmin:
  60       rmin = '0'
  61     else:
  62       rmin = str(self.rmin)
  63     if not self.rmax:
  64       rmax = '+oo'
  65     else:
  66       rmax = str(self.rmax)
  67     return '[%s,%s)' % (rmin, rmax)
  68
  69   def SetReleaseRange(self, rmin, rmax):
  70     self.rmin = rmin
  71     self.rmax = rmax
  72
  73   # True, if Release falls within the interval [self.vmin, self.vmax)
  74   def IsRelease(self, release):
  75     if self.rmax and self.rmax <= release:
  76       return False
  77     if self.rmin and self.rmin > release:
  78       return False
  79     if GetOption('release_debug'):
  80       InfoOut.Log('%f is in %s' % (release, self))
  81     return True
  82
  83   # True, if Release falls within the interval [self.vmin, self.vmax)
  84   def InReleases(self, releases):
  85     if not releases: return False
  86
  87     # Check last release first, since InRange does not match last item
  88     if self.IsRelease(releases[-1]): return True
  89     if len(releases) > 1:
  90       return self.InRange(releases[0], releases[-1])
  91     return False
  92
  93   # True, if interval [vmin, vmax) overlaps interval [self.vmin, self.vmax)
  94   def InRange(self, rmin, rmax):
  95     assert (rmin == None) or rmin < rmax
  96
  97     # An min of None always passes a min bound test
  98     # An max of None always passes a max bound test
  99     if rmin is not None and self.rmax is not None:
 100       if self.rmax <= rmin:
 101         return False
 102     if rmax is not None and self.rmin is not None:
 103       if self.rmin >= rmax:
 104         return False
 105
 106     if GetOption('release_debug'):
 107       InfoOut.Log('%f to %f is in %s' % (rmin, rmax, self))
 108     return True
 109
 110   def Error(self, msg):
 111     ReportReleaseError(msg)
 112
 113   def Warn(self, msg):
 114     ReportReleaseWarning(msg)
 115
 116
 117 #
 118 # IDLReleaseList
 119 #
 120 # IDLReleaseList is a list based container for holding IDLRelease
 121 # objects in order.  The IDLReleaseList can be added to, and searched by
 122 # range.  Objects are stored in order, and must be added in order.
 123 #
 124 class IDLReleaseList(object):
 125   def __init__(self):
 126     self.nodes = []
 127
 128   def FindRelease(self, release):
 129     for node in self.nodes:
 130       if node.IsRelease(release):
 131         return node
 132     return None
 133
 134   def FindRange(self, rmin, rmax):
 135     assert (rmin == None) or rmin != rmax
 136
 137     out = []
 138     for node in self.nodes:
 139       if node.InRange(rmin, rmax):
 140         out.append(node)
 141     return out
 142
 143   def AddNode(self, node):
 144     if GetOption('release_debug'):
 145       InfoOut.Log('\nAdding %s %s' % (node.Location(), node))
 146     last = None
 147
 148     # Check current releases in that namespace
 149     for cver in self.nodes:
 150       if GetOption('release_debug'): InfoOut.Log('  Checking %s' % cver)
 151
 152       # We should only be missing a 'release' tag for the first item.
 153       if not node.rmin:
 154         node.Error('Missing release on overload of previous %s.' %
 155                    cver.Location())
 156         return False
 157
 158       # If the node has no max, then set it to this one
 159       if not cver.rmax:
 160         cver.rmax = node.rmin
 161         if GetOption('release_debug'): InfoOut.Log('  Update %s' % cver)
 162
 163       # if the max and min overlap, than's an error
 164       if cver.rmax > node.rmin:
 165         if node.rmax and cver.rmin >= node.rmax:
 166           node.Error('Declarations out of order.')
 167         else:
 168           node.Error('Overlap in releases: %s vs %s when adding %s' %
 169                      (cver.rmax, node.rmin, node))
 170         return False
 171       last = cver
 172
 173     # Otherwise, the previous max and current min should match
 174     # unless this is the unlikely case of something being only
 175     # temporarily deprecated.
 176     if last and last.rmax != node.rmin:
 177       node.Warn('Gap in release numbers.')
 178
 179     # If we made it here, this new node must be the 'newest'
 180     # and does not overlap with anything previously added, so
 181     # we can add it to the end of the list.
 182     if GetOption('release_debug'): InfoOut.Log('Done %s' % node)
 183     self.nodes.append(node)
 184     return True
 185
 186 #
 187 # IDLReleaseMap
 188 #
 189 # A release map, can map from an float interface release, to a global
 190 # release string.
 191 #
 192 class IDLReleaseMap(object):
 193   def __init__(self, release_info):
 194     self.version_to_release = {}
 195     self.release_to_version = {}
 196     for release, version in release_info:
 197       self.version_to_release[version] = release
 198       self.release_to_version[release] = version
 199     self.releases = sorted(self.release_to_version.keys())
 200     self.versions = sorted(self.version_to_release.keys())
 201
 202   def GetVersion(self, release):
 203     return self.release_to_version.get(release, None)
 204
 205   def GetVersions(self):
 206     return self.versions
 207
 208   def GetRelease(self, version):
 209     return self.version_to_release.get(version, None)
 210
 211   def GetReleases(self):
 212     return self.releases
 213
 214 #
 215 # Test Code
 216 #
 217 def TestReleaseNode():
 218   FooXX = IDLRelease(None, None)
 219   Foo1X = IDLRelease('M14', None)
 220   Foo23 = IDLRelease('M15', 'M16')
 221
 222   assert FooXX.IsRelease('M13')
 223   assert FooXX.IsRelease('M14')
 224   assert FooXX.InRange('M13', 'M13A')
 225   assert FooXX.InRange('M14','M15')
 226
 227   assert not Foo1X.IsRelease('M13')
 228   assert Foo1X.IsRelease('M14')
 229   assert Foo1X.IsRelease('M15')
 230
 231   assert not Foo1X.InRange('M13', 'M14')
 232   assert not Foo1X.InRange('M13A', 'M14')
 233   assert Foo1X.InRange('M14', 'M15')
 234   assert Foo1X.InRange('M15', 'M16')
 235
 236   assert not Foo23.InRange('M13', 'M14')
 237   assert not Foo23.InRange('M13A', 'M14')
 238   assert not Foo23.InRange('M14', 'M15')
 239   assert Foo23.InRange('M15', 'M16')
 240   assert Foo23.InRange('M14', 'M15A')
 241   assert Foo23.InRange('M15B', 'M17')
 242   assert not Foo23.InRange('M16', 'M17')
 243   print "TestReleaseNode - Passed"
 244
 245
 246 def TestReleaseListWarning():
 247   FooXX = IDLRelease(None, None)
 248   Foo1X = IDLRelease('M14', None)
 249   Foo23 = IDLRelease('M15', 'M16')
 250   Foo45 = IDLRelease('M17', 'M18')
 251
 252   # Add nodes out of order should fail
 253   ReportClear()
 254   releases = IDLReleaseList()
 255   assert releases.AddNode(Foo23)
 256   assert releases.AddNode(Foo45)
 257   assert warning
 258   print "TestReleaseListWarning - Passed"
 259
 260
 261 def TestReleaseListError():
 262   FooXX = IDLRelease(None, None)
 263   Foo1X = IDLRelease('M14', None)
 264   Foo23 = IDLRelease('M15', 'M16')
 265   Foo45 = IDLRelease('M17', 'M18')
 266
 267   # Add nodes out of order should fail
 268   ReportClear()
 269   releases = IDLReleaseList()
 270   assert releases.AddNode(FooXX)
 271   assert releases.AddNode(Foo23)
 272   assert not releases.AddNode(Foo1X)
 273   assert error
 274   print "TestReleaseListError - Passed"
 275
 276
 277 def TestReleaseListOK():
 278   FooXX = IDLRelease(None, None)
 279   Foo1X = IDLRelease('M14', None)
 280   Foo23 = IDLRelease('M15', 'M16')
 281   Foo45 = IDLRelease('M17', 'M18')
 282
 283   # Add nodes in order should work
 284   ReportClear()
 285   releases = IDLReleaseList()
 286   assert releases.AddNode(FooXX)
 287   assert releases.AddNode(Foo1X)
 288   assert releases.AddNode(Foo23)
 289   assert not error and not warning
 290   assert releases.AddNode(Foo45)
 291   assert warning
 292
 293   assert releases.FindRelease('M13') == FooXX
 294   assert releases.FindRelease('M14') == Foo1X
 295   assert releases.FindRelease('M15') == Foo23
 296   assert releases.FindRelease('M16') == None
 297   assert releases.FindRelease('M17') == Foo45
 298   assert releases.FindRelease('M18') == None
 299
 300   assert releases.FindRange('M13','M14') == [FooXX]
 301   assert releases.FindRange('M13','M17') == [FooXX, Foo1X, Foo23]
 302   assert releases.FindRange('M16','M17') == []
 303   assert releases.FindRange(None, None) == [FooXX, Foo1X, Foo23, Foo45]
 304
 305   # Verify we can find the correct versions
 306   print "TestReleaseListOK - Passed"
 307
 308
 309 def TestReleaseMap():
 310   print "TestReleaseMap- Passed"
 311
 312
 313 def Main(args):
 314   TestReleaseNode()
 315   TestReleaseListWarning()
 316   TestReleaseListError()
 317   TestReleaseListOK()
 318   print "Passed"
 319   return 0
 320
 321
 322 if __name__ == '__main__':
 323   sys.exit(Main(sys.argv[1:]))