#!/usr/bin/env python
# Copyright 2012 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
IDLRelease for PPAPI
This file defines the behavior of the AST namespace which allows for resolving
a symbol as one or more AST nodes given a Release or range of Releases.
"""
from __future__ import print_function
import sys
from idl_log import ErrOut, InfoOut, WarnOut
from idl_option import GetOption, Option, ParseOptions
Option('release_debug', 'Debug Release data')
Option('wgap', 'Ignore Release gap warning')
#
# Module level functions and data used for testing.
#
error = None
warning = None
def ReportReleaseError(msg):
global error
error = msg
def ReportReleaseWarning(msg):
global warning
warning = msg
def ReportClear():
global error, warning
error = None
warning = None
#
# IDLRelease
#
# IDLRelease is an object which stores the association of a given symbol
# name, with an AST node for a range of Releases for that object.
#
# A vmin value of None indicates that the object begins at the earliest
# available Release number. The value of vmin is always inclusive.
# A vmax value of None indicates that the object is never deprecated, so
# it exists until it is overloaded or until the latest available Release.
# The value of vmax is always exclusive, representing the first Release
# on which the object is no longer valid.
class IDLRelease(object):
def __init__(self, rmin, rmax):
self.rmin = rmin
self.rmax = rmax
def __str__(self):
if not self.rmin:
rmin = '0'
else:
rmin = str(self.rmin)
if not self.rmax:
rmax = '+oo'
else:
rmax = str(self.rmax)
return '[%s,%s)' % (rmin, rmax)
def SetReleaseRange(self, rmin, rmax):
self.rmin = rmin
self.rmax = rmax
# True, if Release falls within the interval [self.vmin, self.vmax)
def IsRelease(self, release):
if self.rmax and self.rmax <= release:
return False
if self.rmin and self.rmin > release:
return False
if GetOption('release_debug'):
InfoOut.Log('%f is in %s' % (release, self))
return True
# True, if Release falls within the interval [self.vmin, self.vmax)
def InReleases(self, releases):
if not releases: return False
# Check last release first, since InRange does not match last item
if self.IsRelease(releases[-1]): return True
if len(releases) > 1:
return self.InRange(releases[0], releases[-1])
return False
# True, if interval [vmin, vmax) overlaps interval [self.vmin, self.vmax)
def InRange(self, rmin, rmax):
assert (rmin == None) or rmin < rmax
# An min of None always passes a min bound test
# An max of None always passes a max bound test
if rmin is not None and self.rmax is not None:
if self.rmax <= rmin:
return False
if rmax is not None and self.rmin is not None:
if self.rmin >= rmax:
return False
if GetOption('release_debug'):
InfoOut.Log('%f to %f is in %s' % (rmin, rmax, self))
return True
def GetMinMax(self, releases = None):
if not releases:
return self.rmin, self.rmax
if not self.rmin:
rmin = releases[0]
else:
rmin = str(self.rmin)
if not self.rmax:
rmax = releases[-1]
else:
rmax = str(self.rmax)
return (rmin, rmax)
def SetMin(self, release):
assert not self.rmin
self.rmin = release
def Error(self, msg):
ReportReleaseError(msg)
def Warn(self, msg):
ReportReleaseWarning(msg)
#
# IDLReleaseList
#
# IDLReleaseList is a list based container for holding IDLRelease
# objects in order. The IDLReleaseList can be added to, and searched by
# range. Objects are stored in order, and must be added in order.
#
class IDLReleaseList(object):
def __init__(self):
self._nodes = []
def GetReleases(self):
return self._nodes
def FindRelease(self, release):
for node in self._nodes:
if node.IsRelease(release):
return node
return None
def FindRange(self, rmin, rmax):
assert (rmin == None) or rmin != rmax
out = []
for node in self._nodes:
if node.InRange(rmin, rmax):
out.append(node)
return out
def AddNode(self, node):
if GetOption('release_debug'):
InfoOut.Log('\nAdding %s %s' % (node.Location(), node))
last = None
# Check current releases in that namespace
for cver in self._nodes:
if GetOption('release_debug'): InfoOut.Log(' Checking %s' % cver)
# We should only be missing a 'release' tag for the first item.
if not node.rmin:
node.Error('Missing release on overload of previous %s.' %
cver.Location())
return False
# If the node has no max, then set it to this one
if not cver.rmax:
cver.rmax = node.rmin
if GetOption('release_debug'): InfoOut.Log(' Update %s' % cver)
# if the max and min overlap, than's an error
if cver.rmax > node.rmin:
if node.rmax and cver.rmin >= node.rmax:
node.Error('Declarations out of order.')
else:
node.Error('Overlap in releases: %s vs %s when adding %s' %
(cver.rmax, node.rmin, node))
return False
last = cver
# Otherwise, the previous max and current min should match
# unless this is the unlikely case of something being only
# temporarily deprecated.
if last and last.rmax != node.rmin:
node.Warn('Gap in release numbers.')
# If we made it here, this new node must be the 'newest'
# and does not overlap with anything previously added, so
# we can add it to the end of the list.
if GetOption('release_debug'): InfoOut.Log('Done %s' % node)
self._nodes.append(node)
return True
#
# IDLReleaseMap
#
# A release map, can map from an float interface release, to a global
# release string.
#
class IDLReleaseMap(object):
def __init__(self, release_info):
self.version_to_release = {}
self.release_to_version = {}
self.release_to_channel = {}
for release, version, channel in release_info:
self.version_to_release[version] = release
self.release_to_version[release] = version
self.release_to_channel[release] = channel
self.releases = sorted(self.release_to_version.keys())
self.versions = sorted(self.version_to_release.keys())
def GetVersion(self, release):
return self.release_to_version.get(release, None)
def GetVersions(self):
return self.versions
def GetRelease(self, version):
return self.version_to_release.get(version, None)
def GetReleases(self):
return self.releases
def GetReleaseRange(self):
return (self.releases[0], self.releases[-1])
def GetVersionRange(self):
return (self.versions[0], self.version[-1])
def GetChannel(self, release):
return self.release_to_channel.get(release, None)
#
# Test Code
#
def TestReleaseNode():
FooXX = IDLRelease(None, None)
Foo1X = IDLRelease('M14', None)
Foo23 = IDLRelease('M15', 'M16')
assert FooXX.IsRelease('M13')
assert FooXX.IsRelease('M14')
assert FooXX.InRange('M13', 'M13A')
assert FooXX.InRange('M14','M15')
assert not Foo1X.IsRelease('M13')
assert Foo1X.IsRelease('M14')
assert Foo1X.IsRelease('M15')
assert not Foo1X.InRange('M13', 'M14')
assert not Foo1X.InRange('M13A', 'M14')
assert Foo1X.InRange('M14', 'M15')
assert Foo1X.InRange('M15', 'M16')
assert not Foo23.InRange('M13', 'M14')
assert not Foo23.InRange('M13A', 'M14')
assert not Foo23.InRange('M14', 'M15')
assert Foo23.InRange('M15', 'M16')
assert Foo23.InRange('M14', 'M15A')
assert Foo23.InRange('M15B', 'M17')
assert not Foo23.InRange('M16', 'M17')
print("TestReleaseNode - Passed")
def TestReleaseListWarning():
FooXX = IDLRelease(None, None)
Foo1X = IDLRelease('M14', None)
Foo23 = IDLRelease('M15', 'M16')
Foo45 = IDLRelease('M17', 'M18')
# Add nodes out of order should fail
ReportClear()
releases = IDLReleaseList()
assert releases.AddNode(Foo23)
assert releases.AddNode(Foo45)
assert warning
print("TestReleaseListWarning - Passed")
def TestReleaseListError():
FooXX = IDLRelease(None, None)
Foo1X = IDLRelease('M14', None)
Foo23 = IDLRelease('M15', 'M16')
Foo45 = IDLRelease('M17', 'M18')
# Add nodes out of order should fail
ReportClear()
releases = IDLReleaseList()
assert releases.AddNode(FooXX)
assert releases.AddNode(Foo23)
assert not releases.AddNode(Foo1X)
assert error
print("TestReleaseListError - Passed")
def TestReleaseListOK():
FooXX = IDLRelease(None, None)
Foo1X = IDLRelease('M14', None)
Foo23 = IDLRelease('M15', 'M16')
Foo45 = IDLRelease('M17', 'M18')
# Add nodes in order should work
ReportClear()
releases = IDLReleaseList()
assert releases.AddNode(FooXX)
assert releases.AddNode(Foo1X)
assert releases.AddNode(Foo23)
assert not error and not warning
assert releases.AddNode(Foo45)
assert warning
assert releases.FindRelease('M13') == FooXX
assert releases.FindRelease('M14') == Foo1X
assert releases.FindRelease('M15') == Foo23
assert releases.FindRelease('M16') == None
assert releases.FindRelease('M17') == Foo45
assert releases.FindRelease('M18') == None
assert releases.FindRange('M13','M14') == [FooXX]
assert releases.FindRange('M13','M17') == [FooXX, Foo1X, Foo23]
assert releases.FindRange('M16','M17') == []
assert releases.FindRange(None, None) == [FooXX, Foo1X, Foo23, Foo45]
# Verify we can find the correct versions
print("TestReleaseListOK - Passed")
def TestReleaseMap():
print("TestReleaseMap- Passed")
def Main(args):
TestReleaseNode()
TestReleaseListWarning()
TestReleaseListError()
TestReleaseListOK()
print("Passed")
return 0
if __name__ == '__main__':
sys.exit(Main(sys.argv[1:]))
Codebase Browser
chromium