def doVcv(self,td): # only relevant for Attribute and Element # print ('dv',self,td,self.qname.local,td.name) if self.valueConstraint is None: shouldnt('vcv') elif td is None: self.vcv=self.valueConstraint[1] return self.vcv else: vct=td.simple() if not vct.isSimple: # the model type of a mixed complex type if not (td.contentType=="mixed" and td.emptiable()): self.error("value constraint not allowed for element with complex type unless its emptiable and mixed: %s"%td.contentType) self.vcv=self.valueConstraint[1] else: if self.xrpr is None: item=self # HACK, to provide a place for actual # value to be stored for cached sForS else: item=self.xrpr.elt.elt # all the way to XMLInfoset res=validateText(vct,self.valueConstraint[1], item,self,vct.facets) if res: self.error("value constraint value %s not of declared type: %s"%(self.valueConstraint[1], res)) self.vcv=self.valueConstraint[1] else: try: self.vcv=item.actualValue # cheat except AttributeError: self.vcv=self.valueConstraint[1] return self.vcv
def __init__(self,sschema,xrpr,ns='ns'): self.sschema=sschema if sschema is not None: self.schema=sschema.current if ns=='ns' and (self.schema is not None) and not sschema.rebuilding: self.targetNamespace=self.schema.targetNS self.xrpr=xrpr if xrpr is not None: if xrpr.__dict__.has_key('name'): self.name=xrpr.name if xrpr.__dict__.has_key('annot') and xrpr.annot: if len(xrpr.annot)!=1: shouldnt("multi-annot: %d"%len(xrpr.annot)) self.annotation=xrpr.annot[0].component if xrpr.elt is not None: ooba=filter(lambda a:a.nsuri, xrpr.elt.actualAttrs) if ooba: ooba=map(lambda a:a.elt,ooba) if self.annotation is None: self.annotation=Annotation(self.sschema,None) if not self.annotation.attrs: self.annotation.attrs=ooba else: self.annotation.attrs=self.annotation.attrs.append(ooba) self.id=self.idCounter Component.idCounter=self.id+1
def doBuiltIns(self,sschema): self.doAbInitios(sschema) # TODO: implement fixed facets for (bitn,basen,facets,idt) in builtinTypeNames: fake=simpleTypeElt(sschema,None) fake.name=bitn fake.restriction=restrictionElt(sschema,None) fake.restriction.init(None) fake.init(None) fake.component.basetypeName=QName(None,basen,XMLSchemaNS) fake.component.variety='atomic' fake.component.idt=idt bit=fake.restriction.component bit.builtin=1 bit.rootName=fake.component.basetype.rootName self.typeTable[bitn]=fake.component for (fc,fv) in facets: nf=fc(sschema,None) fake.restriction.facets[fc.name]=nf if fc.name=="pattern": nf.stringValue=fv else: nf.value=fv for (bitn,basen,idt) in builtinLists: fake=simpleTypeElt(sschema,None) fake.name=bitn fake.list=listElt(sschema,None) fake.list.init(None) fake.init(None) fake.component.basetype=Type.urSimpleType fake.component.variety='list' fake.list.component.itemtypeName=QName(None,basen,XMLSchemaNS) wf=Whitespace(sschema,None) wf.value='collapse' wf.fixed=1 mf=MinLength(sschema,None) mf.value=1 fake.component.facets={'whiteSpace':wf,'minLength':mf} fake.component.idt=idt self.typeTable[bitn]=fake.component ap=Particle(sschema,None, AnyAny(sschema,None),None) ap.term.processContents='lax' ap.occurs=(0,None) if not Type.urType.model.term.particles: Type.urType.model.term.particles.append(ap) au=AttributeUse(sschema,None, AnyAny(sschema,None),'optional') au.attributeDeclaration.processContents='lax' Type.urType.attributeDeclarations={'#any':au} else: shouldnt('dbl ur') self.typeTable['anyType']=Type.urType Type.urSimpleType.schema=Type.urType.schema=self Type.urSimpleType.sschema=Type.urType.sschema=sschema ws=Whitespace(sschema,None) ws.value="preserve" Type.urSimpleType.facets['whiteSpace']=ws self.typeTable['anySimpleType']=Type.urSimpleType
def __getattr__(self,name): if name=='equivalenceClassAffiliation': self.equivalenceClassAffiliation=None if self.equivClassName: #print ('eq',self.name,self.equivClassName) if self.schema.vElementTable.has_key(self.equivClassName): self.equivalenceClassAffiliation=exemplar=self.schema.vElementTable[self.equivClassName] if (self.typeDefinition is not None and exemplar.typeDefinition is not None): if not self.typeDefinition.isSubtype(exemplar.typeDefinition,()): self.error("type {%s}%s not subtype of type {%s}%s of exemplar %s"%(self.typeDefinition.targetNamespace,self.typeDefinition.name, exemplar.typeDefinition.targetNamespace,exemplar.typeDefinition.name, exemplar.qname)) else: self.error("Undefined element %s referenced as equivalence class affiliation"%self.equivClassName) return self.equivalenceClassAffiliation elif name=='equivClass': # first access propagates everything if type(self.scope) is not types.StringType: shouldnt('not global %s'%self.name) for schema in self.sschema.schemas.values(): for ed in schema.elementTable.values(): if not ed.__dict__.has_key('equivClass'): ed.equivClass=[] if (ed.abstract!='true' and ed.equivalenceClassAffiliation is not None): ed.equivalenceClassAffiliation.addECM(ed) return self.equivClass elif name=='typeDefinition': self.typeDefinition=None if self.typeDefinitionName: if self.schema.vTypeTable.has_key(self.typeDefinitionName): self.typeDefinition=self.schema.vTypeTable[self.typeDefinitionName] else: self.error("Undefined type %s referenced as type definition of %s"%(self.typeDefinitionName, self.name)) elif self.equivClassName: if self.equivalenceClassAffiliation is not None: self.typeDefinition=self.equivalenceClassAffiliation.typeDefinition else: shouldnt('etd') return self.typeDefinition elif name=='scope': if isinstance(self.scopeRepr,groupElt): self.scope=None else: self.scope=self.scopeRepr.component return self.scope elif name=='qname': # top-level get them at build time, locals may need them self.qname=QName(None,self.name,self.targetNamespace) return self.qname elif name=='vcv': # value constraint value return self.doVcv(self.typeDefinition) else: raise AttributeError,name
def keyRebuild(self,val): if val is not None: for ic in val: if isinstance(ic,Key): self.keys.append(ic) elif isinstance(ic,Keyref): self.keyrefs.append(ic) elif isinstance(ic,Unique): self.uniques.append(ic) else: shouldnt('bogusic: %s'%ic)
def merge(self,other): # not called anymore shouldnt('merge2') # TODO: check default/fixed -- what else? if self.name!=other.name or self.targetNamespace!=other.targetNamespace: self.error("declaration in a restriction not same name as declaration it corresponds to: {%s}%s vs. {%s}%s"%(self.targetNamespace,self.name,other.targetNamespace,other.name)) if (self.typeDefinition is not None and other.typeDefinition is not None and not self.typeDefinition.isSubtype(other.typeDefinition,['extension']+other.typeDefinition.final)): self.error("type {%s}%s not subtype of type {%s}%s of {%s}%s in restriction"%(self.typeDefinition.targetNamespace,self.typeDefinition.name, other.typeDefinition.targetNamespace,other.typeDefinition.name, self.targetNamespace, self.name)) return self
def has_key(self, key): if key is None: return 0 if not isinstance(key, QName): shouldnt("nk: %s" % key) return 0 s = self.findSchema(key.uri, key.local) if s is None: # not an error to check, we'll record one error when we really go for it return 0 return s.__dict__[self.tablename].has_key(key.local)
def register(self,kind,table): if self.name: if table.has_key(self.name): self.schema.error("attempt to overwrite %s {%s}%s, ignored"%(kind, self.schema.targetNS, self.name), self.xrpr.elt, 1) else: table[self.name]=self self.qname=QName(None,self.name,self.schema.targetNS) else: shouldnt('nc: %s'%self)
def note(self,table): shouldnt('notee') if table.has_key(self.qname): if self.typeDefinition is not table[self.qname].typeDefinition: self.error("illegal redeclaration of %s" % self.qname) elif not (type(self.scope) is types.StringType and type(table[self.qname].scope) is types.StringType): self.error("redeclaration of %s ok - same type\n" % self.qname,1) return table[self.qname] = self if (type(self.scope) is types.StringType and 'substitution' not in self.prohibitedSubstitutions): # check for equivalence classes # is this necessary -- it's quite expensive for decl in self.equivClass: table[decl.qname]=decl
def __getattr__(self,name): if name=='term': self.term=None if self.termName: if self.termType=='element': if self.schema.vElementTable.has_key(self.termName): self.term=self.schema.vElementTable[self.termName] else: self.error("Undefined element %s referenced from content model"%self.termName) elif self.termType=='group': if self.schema.vGroupTable.has_key(self.termName): self.term=self.schema.vGroupTable[self.termName] if self.term.base is not None: # term is an as-yet-unchecked restrictive redefinition # build and check the fsms -- not reused yet, sigh (baseFSM,nd)=UniqueFSM(self.term.base) if not nd: # if nd, then it breaks UPA and we can't check subsumption # the UPA violation will get caught elsewhere (termFSM,nd)=UniqueFSM(self.term) if not nd: # as above res=termFSM.subsumed(baseFSM) if res is not None: termFSM.subsumptionError(self,baseFSM,res,"group", self.termName, "[original %s]"%self.termName,xsvNS) self.term.error("redefined group not a restriction of its original definition") else: self.error("Undefined group %s referenced from content model"%self.termName) else: shouldnt('tnt') else: shouldnt('tn') return self.term elif name=='minOccurs': return str(self.occurs[0]) elif name=='maxOccurs': return str(self.occurs[1] or 'unbounded') else: raise AttributeError,name
def __getattr__(self,name): if name=='attributeDeclaration': if self.attributeDeclarationName and self.nameType=='attribute': if self.schema.vAttributeTable.has_key(self.attributeDeclarationName): self.attributeDeclaration=self.schema.vAttributeTable[self.attributeDeclarationName] else: self.error("Undeclared attribute %s referenced"%(self.attributeDeclarationName)) self.attributeDeclaration=None return self.attributeDeclaration else: shouldnt('attrUse1') elif name=='attributeGroup': if self.attributeDeclarationName and self.nameType=='attributeGroup': if self.schema.vAttributeGroupTable.has_key(self.attributeDeclarationName): self.attributeGroup=self.schema.vAttributeGroupTable[self.attributeDeclarationName] else: self.error("Undeclared attribute group %s referenced"%(self.attributeDeclarationName)) self.attributeGroup=None return self.attributeGroup else: shouldnt('attrUse2') elif name=='vcv': if self.valueConstraint is not None: return self.doVcv(self.attributeDeclaration.typeDefinition) else: self.vcv=self.attributeDeclaration.vcv return self.vcv elif name=='qname': # allow type derivation without chasing refs if self.attributeDeclarationName: self.qname=self.attributeDeclarationName else: self.qname=QName(None,self.attributeDeclaration.name, self.attributeDeclaration.targetNamespace) return self.qname else: raise AttributeError,name
def __init__(self,sschema,xrpr): # note that unlike other components, this one is built _before_ processing # the children of the elt it corresponds to self.xrpr=xrpr self.sschema=sschema self.errors=0 self.locations=[] if xrpr is not None: # these are needed during schema accumulation self.maybeSetVar('targetNS','targetNamespace',None) self.maybeSetVar('elementFormDefault','elementFormDefault','unqualified') self.maybeSetVar('attributeFormDefault','attributeFormDefault', 'unqualified') self.maybeSetVar('finalDefault','finalDefault','') self.maybeSetVar('blockDefault','blockDefault','') if self.targetNS=="": self.error("Empty string is not allowed as value of targetNamespace", xrpr.elt) self.targetNS=None if (sschema.processingInclude and self.targetNS!=sschema.targetNS and (not self.targetNS)): # chameleon include, OK self.targetNS=sschema.targetNS sschema.processingInclude=2 sschema.targetNS=self.targetNS if sschema.schemas.has_key(self.targetNS): shouldnt('oldcopy') oldSchema=sschema.schemas[self.targetNS] # use real tables, we're ephemeral self.locations=oldSchema.locations # broken sschema.current=oldSchema self.typeTable=oldSchema.typeTable self.elementTable=oldSchema.elementTable self.attributeTable=oldSchema.attributeTable self.groupTable=oldSchema.groupTable self.attributeGroupTable=oldSchema.attributeGroupTable self.vTypeTable=oldSchema.vTypeTable self.vElementTable=oldSchema.vElementTable self.vAttributeTable=oldSchema.vAttributeTable self.vGroupTable=oldSchema.vGroupTable self.vAttributeGroupTable=oldSchema.vAttributeGroupTable # copy defaults (they've been saved, will be restored) oldSchema.elementFormDefault=self.elementFormDefault oldSchema.attributeFormDefault=self.attributeFormDefault oldSchema.blockDefault=self.blockDefault oldSchema.finalDefault=self.finalDefault return else: sschema.schemas[self.targetNS]=self sschema.current=self # either we're the first for this NS, or we're the FIRST self.typeTable={} self.elementTable={} self.attributeTable={} self.groupTable={} self.attributeGroupTable={} self.keyUniqueTable={} self.vTypeTable=VMapping(self, "typeTable") self.vElementTable=VMapping(self, "elementTable") self.vAttributeTable=VMapping(self, "attributeTable") self.vGroupTable=VMapping(self, "groupTable") self.vKeyUniqueTable=VMapping(self, "keyUniqueTable") self.vAttributeGroupTable=VMapping(self, "attributeGroupTable")
def __getattr__(self,name): if name=='facets': newTable=self.xrpr.facets if newTable.has_key('pattern'): # special treatment -- multiple patterns are branches pf=newTable['pattern'] if (not self.builtin) and len(pf.stringValue)>1: pf.stringValue=['|'.join(map(lambda p:'('+p+')',pf.stringValue))] if (self.base is None or self.variety=='unknown' or (self.variety=='atomic' and self.primitiveType is None)): # unknown means earlier error, bail out self.facets={} return {} oldTable=self.base.facets ft=self.base if ft.variety!=self.variety: self.error("type with variety %s must not have base type defn with variety %s"%(self.variety,ft.variety)) if self.variety=='atomic': auth=self.primitiveType tname=self.base.name elif self.variety=='list': tname='List' auth=List ft=self.base if 'whiteSpace' not in oldTable: nwsf=Whitespace(self.sschema,self.base.elt) nwsf.value='collapse' nwsf.fixed=1 oldTable['whiteSpace']=nwsf elif self.variety=='union': tname='Union' auth=Union ft=self.base else: shouldnt('bogusv: %s'%self.variety) self.facets=oldTable.copy() allowed=auth.allowedFacets #print ('r',newTable.keys(),oldTable.keys()) for facetName in newTable.keys(): if facetName in allowed: newF=newTable[facetName] newF.type=ft newF.auth=auth for facetName in newTable.keys(): newF=newTable[facetName] if facetName in allowed: if oldTable.has_key(facetName): oldF=oldTable[facetName] else: oldF=None if oldF is not None and oldF.fixed and newF.value!=oldF.value: self.error("facet %s is fixed in basetype %s, cannot be changed"%(facetName,tname)) newNew=getattr(ft,_checkFacetTable[facetName])(facetName, oldF, newF, newTable, self, oldTable) if newNew is not None: self.facets[facetName]=newNew else: self.error("facet %s not allowed on type %s"%(facetName,tname)) return self.facets elif name not in ('variety','rootName','primitiveType','memberTypes', 'itemType','base','validateText'): raise AttributeError,name if not self.__dict__.has_key('base'): if self.super.basetype is not None: self.base=self.super.basetype if isinstance(self.base,AbInitio): self.primitiveType=self.base if name=='primitiveType': return self.base else: # error already signalled . . . self.base=None return None if name=='base': return self.base elif self.base is not None: return getattr(self.base,name) else: return None
def attributeUseRebuild(self,val): if self.__dict__.has_key('attributeDeclarations'): shouldnt('xyzzy') self.attributeDeclarations=val