memberNsName = unionNode.qName2NsName(memberType, 1)
self._checkBaseType(unionNode, memberNsName,
self.xsdTypeDict)
if self.xsdTypeDict.has_key(memberNsName):
if self.xsdTypeDict[memberNsName].getLocalName(
) != "simpleType":
self._addError(
"MemberType %s must be a simple type!" %
(repr(memberNsName)), unionNode)
patternNodes, dummy, dummy = self.inputRoot.getXPathList(
".//%(prefix)spattern" % vars())
for patternNode in patternNodes:
pattern = patternNode["value"]
try:
pattern = substituteSpecialEscChars(pattern)
try:
test = re.compile(pattern)
except Exception, errstr:
self._addError(str(errstr), patternNode)
self._addError(
"%s is not a valid regular expression!" %
(repr(patternNode["value"])), patternNode)
except SyntaxError, errInst:
self._addError(repr(errInst[0]), patternNode)
########################################
# additional checks for keyrefs
#
def _checkIdentityConstraintsSecondLevel(self):
identityConstraintNodes, dummy, dummy = self.inputRoot.getXPathList(
break
else:
self._addError("Union must not be empty!", unionNode)
else:
for memberType in string.split(unionNode["memberTypes"]):
memberNsName = unionNode.qName2NsName(memberType, 1)
self._checkBaseType(unionNode, memberNsName, self.xsdTypeDict)
if self.xsdTypeDict.has_key(memberNsName):
if self.xsdTypeDict[memberNsName].getLocalName() != "simpleType":
self._addError("MemberType %s must be a simple type!" % (repr(memberNsName)), unionNode)
patternNodes, dummy, dummy = self.inputRoot.getXPathList(".//%(prefix)spattern" % vars())
for patternNode in patternNodes:
pattern = patternNode["value"]
try:
pattern = substituteSpecialEscChars(pattern)
try:
test = re.compile(pattern)
except Exception, errstr:
self._addError(str(errstr), patternNode)
self._addError("%s is not a valid regular expression!" % (repr(patternNode["value"])), patternNode)
except SyntaxError, errInst:
self._addError(repr(errInst[0]), patternNode)
########################################
# additional checks for keyrefs
#
def _checkIdentityConstraintsSecondLevel(self):
identityConstraintNodes, dummy, dummy = self.inputRoot.getXPathList(".//%sunique" % (self.inputNsPrefixString))
for identityConstraintNode in identityConstraintNodes:
# check for unique ID
def _checkRestrictionTag (self, inputNode, xsdElement, attrName, attributeValue, returnDict, idCheck):
savedAttrValue = attributeValue
# first check against base type
self.checkBaseType (inputNode, xsdElement, attrName, attributeValue, returnDict, idCheck)
minExcl = xsdElement.getFirstChildNS(self.xsdNsURI, "minExclusive")
minIncl = xsdElement.getFirstChildNS(self.xsdNsURI, "minInclusive")
maxExcl = xsdElement.getFirstChildNS(self.xsdNsURI, "maxExclusive")
maxIncl = xsdElement.getFirstChildNS(self.xsdNsURI, "maxInclusive")
if minExcl != None:
minExclReturnDict = {"BaseTypes":[], "primitiveType":None}
minExclValue = minExcl.getAttribute("value")
self.checkBaseType (inputNode, xsdElement, attrName, minExclValue, minExclReturnDict, idCheck=0)
if returnDict.has_key("orderedValue") and minExclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] <= minExclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is <= minExclusive (%s)" %(repr(attrName), repr(attributeValue), repr(minExclValue)))
elif minIncl != None:
minInclReturnDict = {"BaseTypes":[], "primitiveType":None}
minInclValue = minIncl.getAttribute("value")
self.checkBaseType (inputNode, xsdElement, attrName, minInclValue, minInclReturnDict, idCheck=0)
if returnDict.has_key("orderedValue") and minInclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] < minInclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is < minInclusive (%s)" %(repr(attrName), repr(attributeValue), repr(minInclValue)))
if maxExcl != None:
maxExclReturnDict = {"BaseTypes":[], "primitiveType":None}
maxExclValue = maxExcl.getAttribute("value")
self.checkBaseType (inputNode, xsdElement, attrName, maxExclValue, maxExclReturnDict, idCheck=0)
if returnDict.has_key("orderedValue") and maxExclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] >= maxExclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is >= maxExclusive (%s)" %(repr(attrName), repr(attributeValue), repr(maxExclValue)))
elif maxIncl != None:
maxInclReturnDict = {"BaseTypes":[], "primitiveType":None}
maxInclValue = maxIncl.getAttribute("value")
self.checkBaseType (inputNode, xsdElement, attrName, maxInclValue, maxInclReturnDict, idCheck=0)
if returnDict.has_key("orderedValue") and maxInclReturnDict.has_key("orderedValue"):
if returnDict["orderedValue"] > maxInclReturnDict["orderedValue"]:
raise SimpleTypeError ("Value of %s (%s) is > maxInclusive (%s)" %(repr(attrName), repr(attributeValue), repr(maxInclValue)))
totalDigitsNode = xsdElement.getFirstChildNS(self.xsdNsURI, "totalDigits")
if totalDigitsNode != None:
orderedValueStr = repr(returnDict["orderedValue"])
digits = re.findall("\d" ,orderedValueStr)
if digits[0] == "0" and len(digits) > 1:
digits = digits[1:]
totalDigitsValue = totalDigitsNode.getAttribute("value")
if totalDigitsNode.getAttribute("fixed") == "true":
if len(digits) != string.atoi(totalDigitsValue):
raise SimpleTypeError ("Total number of digits != %s for %s (%s)" %(repr(totalDigitsValue), repr(attrName), repr(attributeValue)))
else:
if len(digits) > string.atoi(totalDigitsValue):
raise SimpleTypeError ("Total number of digits > %s for %s (%s)" %(repr(totalDigitsValue), repr(attrName), repr(attributeValue)))
fractionDigitsNode = xsdElement.getFirstChildNS(self.xsdNsURI, "fractionDigits")
if fractionDigitsNode != None:
orderedValueStr = repr(returnDict["orderedValue"])
fractionDigitsValue = fractionDigitsNode.getAttribute("value")
result = re.search("(?P<intDigits>\d*)(?P<dot>\.)(?P<fracDigits>\d+)", orderedValueStr)
if result != None:
numberOfFracDigits = len (result.group('fracDigits'))
else:
numberOfFracDigits = 0
if fractionDigitsNode.getAttribute("fixed") == "true" and numberOfFracDigits != string.atoi(fractionDigitsValue):
raise SimpleTypeError ("Fraction number of digits != %s for %s (%s)" %(repr(fractionDigitsValue), repr(attrName), repr(attributeValue)))
elif numberOfFracDigits > string.atoi(fractionDigitsValue):
raise SimpleTypeError ("Fraction number of digits > %s for %s (%s)" %(repr(fractionDigitsValue), repr(attrName), repr(attributeValue)))
if returnDict.has_key("length"):
lengthNode = xsdElement.getFirstChildNS(self.xsdNsURI, "length")
if lengthNode != None:
length = string.atoi(lengthNode.getAttribute("value"))
if returnDict["length"] != length:
raise SimpleTypeError ("Length of %s (%s) must be %d!" %(repr(attrName), repr(attributeValue), length))
minLengthNode = xsdElement.getFirstChildNS(self.xsdNsURI, "minLength")
if minLengthNode != None:
minLength = string.atoi(minLengthNode.getAttribute("value"))
if returnDict["length"] < minLength:
raise SimpleTypeError ("Length of %s (%s) must be >= %d!" %(repr(attrName), repr(attributeValue), minLength))
maxLengthNode = xsdElement.getFirstChildNS(self.xsdNsURI, "maxLength")
if maxLengthNode != None:
maxLength = string.atoi(maxLengthNode.getAttribute("value"))
if returnDict["length"] > maxLength:
raise SimpleTypeError ("Length of %s (%s) must be <= %d!" %(repr(attrName), repr(attributeValue), maxLength))
whiteSpace = xsdElement.getFirstChildNS(self.xsdNsURI, "whiteSpace")
if whiteSpace != None:
returnDict["wsAction"] = whiteSpace.getAttribute("value")
if returnDict["wsAction"] == "replace":
normalizedValue = normalizeString(attributeValue)
if normalizedValue != attributeValue:
returnDict["adaptedAttrValue"] = normalizedValue
elif returnDict["wsAction"] == "collapse":
collapsedValue = collapseString(attributeValue)
if collapsedValue != attributeValue:
returnDict["adaptedAttrValue"] = collapsedValue
enumerationElementList = xsdElement.getChildrenNS(self.xsdNsURI, "enumeration")
if enumerationElementList != []:
if returnDict.has_key("orderedValue"):
attributeValue = returnDict["orderedValue"]
elif returnDict.has_key("adaptedAttrValue"):
attributeValue = returnDict["adaptedAttrValue"]
for enumeration in enumerationElementList:
enumReturnDict = {"BaseTypes":[], "primitiveType":None}
enumValue = enumeration["value"]
self.checkBaseType (inputNode, xsdElement, attrName, enumValue, enumReturnDict, idCheck=0)
if enumReturnDict.has_key("orderedValue"):
enumValue = enumReturnDict["orderedValue"]
elif enumReturnDict.has_key("adaptedAttrValue"):
enumValue = enumReturnDict["adaptedAttrValue"]
if enumValue == attributeValue:
break
else:
raise SimpleTypeError ("Enumeration value %s not allowed!" %repr(attributeValue))
if returnDict.has_key("adaptedAttrValue"):
attributeValue = returnDict["adaptedAttrValue"]
patternMatch = 1
notMatchedPatternList = []
for patternNode in xsdElement.getChildrenNS(self.xsdNsURI, "pattern"):
rePattern = patternNode.getAttribute("value")
intRePattern = rePattern
try:
intRePattern = substituteSpecialEscChars (intRePattern)
except SyntaxError, errInst:
raise SimpleTypeError, str(errInst)
patternMatch = self._matchesPattern (intRePattern, attributeValue)
if patternMatch:
break
else:
notMatchedPatternList.append(rePattern)
except SimpleTypeError, errstr:
pass
raise SimpleTypeError ("%s (%s) is no valid union member type!" %(repr(attrName), repr(attributeValue)))
###############################################################
# Base type check functions
###############################################################
reDecimal = re.compile("[+-]?[0-9]*\.?[0-9]+", re.U)
reInteger = re.compile("[+-]?[0-9]+", re.U)
reDouble = re.compile("([+-]?[0-9]*\.?[0-9]+([eE][+\-]?[0-9]+)?)|INF|-INF|NaN", re.U)
reHexBinary = re.compile("([a-fA-F0-9]{2})*", re.U)
reBase64Binary = re.compile("(?P<validBits>[a-zA-Z0-9+/]*)={0,3}", re.U)
reQName = re.compile(substituteSpecialEscChars("\i\c*"), re.U)
reDuration = re.compile("-?P(?P<years>\d+Y)?(?P<months>\d+M)?(?P<days>\d+D)?(T(?P<hours>\d+H)?(?P<minutes>\d+M)?((?P<seconds>\d+)(?P<fracsec>\.\d+)?S)?)?", re.U)
reDateTime = re.compile("(?P<date>\d{4}-\d{2}-\d{2})T(?P<time>\d{2}:\d{2}:\d{2}(\.\d+)?)(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reDate = re.compile("\d{4}-\d{2}-\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reTime = re.compile("(?P<time>\d{2}:\d{2}:\d{2})(?P<fracsec>\.\d+)?(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reYearMonth = re.compile("\d{4}-\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reMonthDay = re.compile("--\d{2}-\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reYear = re.compile("(?P<year>\d{1,4})(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reMonth = re.compile("--\d{2}(--)?(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reDay = re.compile("---\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
def _checkAnySimpleType (inputNode, simpleType, attributeValue, returnDict):
# TODO: Nothing to check??
returnDict["length"] = len(attributeValue)
def _checkRestrictionTag(self, inputNode, xsdElement, attrName,
attributeValue, returnDict, idCheck):
savedAttrValue = attributeValue
# first check against base type
self.checkBaseType(inputNode, xsdElement, attrName, attributeValue,
returnDict, idCheck)
minExcl = xsdElement.getFirstChildNS(self.xsdNsURI, "minExclusive")
minIncl = xsdElement.getFirstChildNS(self.xsdNsURI, "minInclusive")
maxExcl = xsdElement.getFirstChildNS(self.xsdNsURI, "maxExclusive")
maxIncl = xsdElement.getFirstChildNS(self.xsdNsURI, "maxInclusive")
if minExcl != None:
minExclReturnDict = {"BaseTypes": [], "primitiveType": None}
minExclValue = minExcl.getAttribute("value")
self.checkBaseType(inputNode,
xsdElement,
attrName,
minExclValue,
minExclReturnDict,
idCheck=0)
if returnDict.has_key(
"orderedValue") and minExclReturnDict.has_key(
"orderedValue"):
if returnDict["orderedValue"] <= minExclReturnDict[
"orderedValue"]:
raise SimpleTypeError(
"Value of %s (%s) is <= minExclusive (%s)" %
(repr(attrName), repr(attributeValue),
repr(minExclValue)))
elif minIncl != None:
minInclReturnDict = {"BaseTypes": [], "primitiveType": None}
minInclValue = minIncl.getAttribute("value")
self.checkBaseType(inputNode,
xsdElement,
attrName,
minInclValue,
minInclReturnDict,
idCheck=0)
if returnDict.has_key(
"orderedValue") and minInclReturnDict.has_key(
"orderedValue"):
if returnDict["orderedValue"] < minInclReturnDict[
"orderedValue"]:
raise SimpleTypeError(
"Value of %s (%s) is < minInclusive (%s)" %
(repr(attrName), repr(attributeValue),
repr(minInclValue)))
if maxExcl != None:
maxExclReturnDict = {"BaseTypes": [], "primitiveType": None}
maxExclValue = maxExcl.getAttribute("value")
self.checkBaseType(inputNode,
xsdElement,
attrName,
maxExclValue,
maxExclReturnDict,
idCheck=0)
if returnDict.has_key(
"orderedValue") and maxExclReturnDict.has_key(
"orderedValue"):
if returnDict["orderedValue"] >= maxExclReturnDict[
"orderedValue"]:
raise SimpleTypeError(
"Value of %s (%s) is >= maxExclusive (%s)" %
(repr(attrName), repr(attributeValue),
repr(maxExclValue)))
elif maxIncl != None:
maxInclReturnDict = {"BaseTypes": [], "primitiveType": None}
maxInclValue = maxIncl.getAttribute("value")
self.checkBaseType(inputNode,
xsdElement,
attrName,
maxInclValue,
maxInclReturnDict,
idCheck=0)
if returnDict.has_key(
"orderedValue") and maxInclReturnDict.has_key(
"orderedValue"):
if returnDict["orderedValue"] > maxInclReturnDict[
"orderedValue"]:
raise SimpleTypeError(
"Value of %s (%s) is > maxInclusive (%s)" %
(repr(attrName), repr(attributeValue),
repr(maxInclValue)))
totalDigitsNode = xsdElement.getFirstChildNS(self.xsdNsURI,
"totalDigits")
if totalDigitsNode != None:
orderedValueStr = repr(returnDict["orderedValue"])
digits = re.findall("\d", orderedValueStr)
if digits[0] == "0" and len(digits) > 1:
digits = digits[1:]
totalDigitsValue = totalDigitsNode.getAttribute("value")
if totalDigitsNode.getAttribute("fixed") == "true":
if len(digits) != string.atoi(totalDigitsValue):
raise SimpleTypeError(
"Total number of digits != %s for %s (%s)" %
(repr(totalDigitsValue), repr(attrName),
repr(attributeValue)))
else:
if len(digits) > string.atoi(totalDigitsValue):
raise SimpleTypeError(
"Total number of digits > %s for %s (%s)" %
(repr(totalDigitsValue), repr(attrName),
repr(attributeValue)))
fractionDigitsNode = xsdElement.getFirstChildNS(
self.xsdNsURI, "fractionDigits")
if fractionDigitsNode != None:
orderedValueStr = repr(returnDict["orderedValue"])
fractionDigitsValue = fractionDigitsNode.getAttribute("value")
result = re.search(
"(?P<intDigits>\d*)(?P<dot>\.)(?P<fracDigits>\d+)",
orderedValueStr)
if result != None:
numberOfFracDigits = len(result.group('fracDigits'))
else:
numberOfFracDigits = 0
if fractionDigitsNode.getAttribute(
"fixed") == "true" and numberOfFracDigits != string.atoi(
fractionDigitsValue):
raise SimpleTypeError(
"Fraction number of digits != %s for %s (%s)" %
(repr(fractionDigitsValue), repr(attrName),
repr(attributeValue)))
elif numberOfFracDigits > string.atoi(fractionDigitsValue):
raise SimpleTypeError(
"Fraction number of digits > %s for %s (%s)" %
(repr(fractionDigitsValue), repr(attrName),
repr(attributeValue)))
if returnDict.has_key("length"):
lengthNode = xsdElement.getFirstChildNS(self.xsdNsURI, "length")
if lengthNode != None:
length = string.atoi(lengthNode.getAttribute("value"))
if returnDict["length"] != length:
raise SimpleTypeError(
"Length of %s (%s) must be %d!" %
(repr(attrName), repr(attributeValue), length))
minLengthNode = xsdElement.getFirstChildNS(self.xsdNsURI,
"minLength")
if minLengthNode != None:
minLength = string.atoi(minLengthNode.getAttribute("value"))
if returnDict["length"] < minLength:
raise SimpleTypeError(
"Length of %s (%s) must be >= %d!" %
(repr(attrName), repr(attributeValue), minLength))
maxLengthNode = xsdElement.getFirstChildNS(self.xsdNsURI,
"maxLength")
if maxLengthNode != None:
maxLength = string.atoi(maxLengthNode.getAttribute("value"))
if returnDict["length"] > maxLength:
raise SimpleTypeError(
"Length of %s (%s) must be <= %d!" %
(repr(attrName), repr(attributeValue), maxLength))
whiteSpace = xsdElement.getFirstChildNS(self.xsdNsURI, "whiteSpace")
if whiteSpace != None:
returnDict["wsAction"] = whiteSpace.getAttribute("value")
if returnDict["wsAction"] == "replace":
normalizedValue = normalizeString(attributeValue)
if normalizedValue != attributeValue:
returnDict["adaptedAttrValue"] = normalizedValue
elif returnDict["wsAction"] == "collapse":
collapsedValue = collapseString(attributeValue)
if collapsedValue != attributeValue:
returnDict["adaptedAttrValue"] = collapsedValue
enumerationElementList = xsdElement.getChildrenNS(
self.xsdNsURI, "enumeration")
if enumerationElementList != []:
if returnDict.has_key("orderedValue"):
attributeValue = returnDict["orderedValue"]
elif returnDict.has_key("adaptedAttrValue"):
attributeValue = returnDict["adaptedAttrValue"]
for enumeration in enumerationElementList:
enumReturnDict = {"BaseTypes": [], "primitiveType": None}
enumValue = enumeration["value"]
self.checkBaseType(inputNode,
xsdElement,
attrName,
enumValue,
enumReturnDict,
idCheck=0)
if enumReturnDict.has_key("orderedValue"):
enumValue = enumReturnDict["orderedValue"]
elif enumReturnDict.has_key("adaptedAttrValue"):
enumValue = enumReturnDict["adaptedAttrValue"]
if enumValue == attributeValue:
break
else:
raise SimpleTypeError("Enumeration value %s not allowed!" %
repr(attributeValue))
if returnDict.has_key("adaptedAttrValue"):
attributeValue = returnDict["adaptedAttrValue"]
patternMatch = 1
notMatchedPatternList = []
for patternNode in xsdElement.getChildrenNS(self.xsdNsURI, "pattern"):
rePattern = patternNode.getAttribute("value")
intRePattern = rePattern
try:
intRePattern = substituteSpecialEscChars(intRePattern)
except SyntaxError, errInst:
raise SimpleTypeError, str(errInst)
patternMatch = self._matchesPattern(intRePattern, attributeValue)
if patternMatch:
break
else:
notMatchedPatternList.append(rePattern)
raise SimpleTypeError("%s (%s) is no valid union member type!" %
(repr(attrName), repr(attributeValue)))
###############################################################
# Base type check functions
###############################################################
reDecimal = re.compile("[+-]?[0-9]*\.?[0-9]+", re.U)
reInteger = re.compile("[+-]?[0-9]+", re.U)
reDouble = re.compile("([+-]?[0-9]*\.?[0-9]+([eE][+\-]?[0-9]+)?)|INF|-INF|NaN",
re.U)
reHexBinary = re.compile("([a-fA-F0-9]{2})*", re.U)
reBase64Binary = re.compile("(?P<validBits>[a-zA-Z0-9+/]*)={0,3}", re.U)
reQName = re.compile(substituteSpecialEscChars("\i\c*"), re.U)
reDuration = re.compile(
"-?P(?P<years>\d+Y)?(?P<months>\d+M)?(?P<days>\d+D)?(T(?P<hours>\d+H)?(?P<minutes>\d+M)?((?P<seconds>\d+)(?P<fracsec>\.\d+)?S)?)?",
re.U)
reDateTime = re.compile(
"(?P<date>\d{4}-\d{2}-\d{2})T(?P<time>\d{2}:\d{2}:\d{2}(\.\d+)?)(?P<offset>Z|[+-]\d{2}:\d{2})?",
re.U)
reDate = re.compile("\d{4}-\d{2}-\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reTime = re.compile(
"(?P<time>\d{2}:\d{2}:\d{2})(?P<fracsec>\.\d+)?(?P<offset>Z|[+-]\d{2}:\d{2})?",
re.U)
reYearMonth = re.compile("\d{4}-\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reMonthDay = re.compile("--\d{2}-\d{2}(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reYear = re.compile("(?P<year>\d{1,4})(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)
reMonth = re.compile("--\d{2}(--)?(?P<offset>Z|[+-]\d{2}:\d{2})?", re.U)