Lines Matching refs:self
40 def __init__(self, argument
52 self.cgen = cgen
53 self.direction = direction
54 self.processSimple = "write" if self.direction == "write" else "read"
55 self.forApiOutput = forApiOutput
57 self.checked = False
59 self.streamVarName = streamVarName
60 self.rootTypeVarName = rootTypeVarName
61 self.inputVarName = inputVarName
62 self.marshalPrefix = marshalPrefix
64 …self.exprAccessor = lambda t: self.cgen.generalAccess(t, parentVarName = self.inputVarName, asPtr …
65 …self.exprValueAccessor = lambda t: self.cgen.generalAccess(t, parentVarName = self.inputVarName, a…
66 …self.exprPrimitiveValueAccessor = lambda t: self.cgen.generalAccess(t, parentVarName = self.inputV…
67 … self.lenAccessor = lambda t: self.cgen.generalLengthAccess(t, parentVarName = self.inputVarName)
68 self.lenAccessorGuard = lambda t: self.cgen.generalLengthAccessGuard(
69 t, parentVarName=self.inputVarName)
70 … self.filterVarAccessor = lambda t: self.cgen.filterVarAccess(t, parentVarName = self.inputVarName)
72 self.dynAlloc = dynAlloc
73 self.mapHandles = mapHandles
74 self.handleMapOverwrites = handleMapOverwrites
75 self.doFiltering = doFiltering
77 def getTypeForStreaming(self, vulkanType): argument
86 if self.direction == "write":
91 def makeCastExpr(self, vulkanType): argument
93 self.cgen.makeCTypeDecl(vulkanType, useParamName=False))
95 def genStreamCall(self, vulkanType, toStreamExpr, sizeExpr): argument
96 varname = self.streamVarName
97 func = self.processSimple
98 cast = self.makeCastExpr(self.getTypeForStreaming(vulkanType))
100 self.cgen.stmt(
103 def genPrimitiveStreamCall(self, vulkanType, access): argument
104 varname = self.streamVarName
106 self.cgen.streamPrimitive(
107 self.typeInfo,
111 direction=self.direction)
113 def genHandleMappingCall(self, vulkanType, access, lenAccess): argument
121 handle64Var = self.cgen.var()
123 self.cgen.beginIf(lenAccess)
124 self.cgen.stmt("uint64_t* %s" % handle64Var)
125 self.cgen.stmt(
127 (self.streamVarName, handle64Var, lenAccess))
132 self.cgen.stmt("uint64_t %s" % handle64Var)
137 if self.direction == "write":
138 if self.handleMapOverwrites:
139 self.cgen.stmt(
142 self.cgen.stmt(
144 (self.streamVarName, vulkanType.typeName, vulkanType.typeName,
146 self.genStreamCall(vulkanType, access, "8 * %s" % lenAccess)
148 self.cgen.stmt(
150 (self.streamVarName, vulkanType.typeName,
153 self.genStreamCall(handle64VarType, handle64VarAccess, handle64Bytes)
155 self.genStreamCall(handle64VarType, handle64VarAccess, handle64Bytes)
156 self.cgen.stmt(
158 (self.streamVarName, vulkanType.typeName,
160 self.makeCastExpr(vulkanType.getForNonConstAccess()), access,
164 self.cgen.endIf()
166 def doAllocSpace(self, vulkanType): argument
167 if self.dynAlloc and self.direction == "read":
168 access = self.exprAccessor(vulkanType)
169 lenAccess = self.lenAccessor(vulkanType)
170 sizeof = self.cgen.sizeofExpr( \
177 self.cgen.stmt( \
179 (self.streamVarName,
182 def getOptionalStringFeatureExpr(self, vulkanType): argument
186 featureExpr = "%s->getFeatureBits() & %s" % (self.streamVarName, splitted[1])
190 def onCheck(self, vulkanType): argument
192 if self.forApiOutput:
195 featureExpr = self.getOptionalStringFeatureExpr(vulkanType);
197 self.checked = True
199 access = self.exprAccessor(vulkanType)
203 self.cgen.line("// WARNING PTR CHECK")
204 if (self.dynAlloc and self.direction == "read") or self.direction == "write":
205 checkAccess = self.exprAccessor(vulkanType)
207 sizeExpr = self.cgen.sizeofExpr(vulkanType)
210 self.cgen.stmt("%s %s" % (
211 self.cgen.makeCTypeDecl(vulkanType, useParamName = False), checkName))
214 sizeExpr = self.cgen.sizeofExpr(vulkanType)
218 self.cgen.beginIf(featureExpr)
220 self.genPrimitiveStreamCall(
225 self.cgen.endIf()
228 self.cgen.beginIf("(!(%s) || %s)" % (featureExpr, access))
230 self.cgen.beginIf(access)
233 self.cgen.beginIf("!(%s)" % checkName)
234 self.cgen.stmt(
236 self.cgen.endIf()
239 def onCheckWithNullOptionalStringFeature(self, vulkanType): argument
240 …self.cgen.beginIf("%s->getFeatureBits() & VULKAN_STREAM_FEATURE_NULL_OPTIONAL_STRINGS_BIT" % self.…
241 self.onCheck(vulkanType)
243 def endCheckWithNullOptionalStringFeature(self, vulkanType): argument
244 self.endCheck(vulkanType)
245 self.cgen.endIf()
246 self.cgen.beginElse()
248 def finalCheckWithNullOptionalStringFeature(self, vulkanType): argument
249 self.cgen.endElse()
251 def endCheck(self, vulkanType): argument
253 if self.checked:
254 self.cgen.endIf()
255 self.checked = False
257 def genFilterFunc(self, filterfunc, env): argument
288 return self.getEnvAccessExpr(atomname)
297 return self.getPointerIndirectionLevels(atomname)
331 def beginFilterGuard(self, vulkanType): argument
335 if self.doFiltering == False:
338 filterVarAccess = self.getEnvAccessExpr(vulkanType.filterVar)
344 …filterFeature = "%s->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT" % self.streamVa…
350 … filterFuncExpr = self.genFilterFunc(vulkanType.filterFunc, self.currentStructInfo.environment)
356 self.cgen.beginIf(filterVarAccess)
358 self.cgen.beginIf("(!(%s) || (%s))" % (filterFeature, filterValsExpr))
360 self.cgen.beginIf("(!(%s) || (%s))" % (filterFeature, filterFuncExpr))
362 def endFilterGuard(self, vulkanType, cleanupExpr=None): argument
366 if self.doFiltering == False:
370 self.cgen.endIf()
372 self.cgen.endIf()
373 self.cgen.beginElse()
374 self.cgen.stmt(cleanupExpr)
375 self.cgen.endElse()
377 def getEnvAccessExpr(self, varName): argument
378 parentEnvEntry = self.currentStructInfo.environment.get(varName, None)
384 …envAccess = self.exprValueAccessor(list(filter(lambda member: member.paramName == varName, self.cu…
391 def getPointerIndirectionLevels(self, varName): argument
392 parentEnvEntry = self.currentStructInfo.environment.get(varName, None)
398 …return list(filter(lambda member: member.paramName == varName, self.currentStructInfo.members))[0]…
406 def onCompoundType(self, vulkanType): argument
408 access = self.exprAccessor(vulkanType)
409 lenAccess = self.lenAccessor(vulkanType)
410 lenAccessGuard = self.lenAccessorGuard(vulkanType)
412 self.beginFilterGuard(vulkanType)
415 self.doAllocSpace(vulkanType)
419 self.cgen.beginIf(lenAccessGuard)
425 self.cgen.beginFor(forInit, forCond, forIncr)
427 accessWithCast = "%s(%s)" % (self.makeCastExpr(
428 self.getTypeForStreaming(vulkanType)), access)
430 callParams = [self.streamVarName, self.rootTypeVarName, accessWithCast]
433 callParams.append(self.getEnvAccessExpr(localName))
435 self.cgen.funcCall(None, self.marshalPrefix + vulkanType.typeName,
439 self.cgen.endFor()
441 self.cgen.endIf()
443 if self.direction == "read":
444 self.endFilterGuard(vulkanType, "%s = 0" % self.exprAccessor(vulkanType))
446 self.endFilterGuard(vulkanType)
448 def onString(self, vulkanType): argument
450 access = self.exprAccessor(vulkanType)
452 if self.direction == "write":
453 self.cgen.stmt("%s->putString(%s)" % (self.streamVarName, access))
456 self.makeCastExpr( \
457 self.getTypeForStreaming( \
460 self.cgen.stmt( \
461 "%s->loadStringInPlace(%s&%s)" % (self.streamVarName, castExpr, access))
463 def onStringArray(self, vulkanType): argument
465 access = self.exprAccessor(vulkanType)
466 lenAccess = self.lenAccessor(vulkanType)
468 if self.direction == "write":
469 self.cgen.stmt("saveStringArray(%s, %s, %s)" % (self.streamVarName,
473 self.makeCastExpr( \
474 self.getTypeForStreaming( \
477 … self.cgen.stmt("%s->loadStringArrayInPlace(%s&%s)" % (self.streamVarName, castExpr, access))
479 def onStaticArr(self, vulkanType): argument
480 access = self.exprValueAccessor(vulkanType)
481 lenAccess = self.lenAccessor(vulkanType)
482 finalLenExpr = "%s * %s" % (lenAccess, self.cgen.sizeofExpr(vulkanType))
483 self.genStreamCall(vulkanType, access, finalLenExpr)
489 def overwriteSType(self, vulkanType): argument
490 if self.direction == "read":
493 sTypeAccess = self.exprAccessor(sTypeParam)
497 self.cgen.stmt("%s = %s" %
500 def onStructExtension(self, vulkanType): argument
501 self.overwriteSType(vulkanType)
506 access = self.exprAccessor(vulkanType)
509 if self.direction == "read":
514 sTypeAccess = self.exprAccessor(sTypeParam)
515 self.cgen.beginIf("%s == VK_STRUCTURE_TYPE_MAX_ENUM" %
516 self.rootTypeVarName)
517 self.cgen.stmt("%s = %s" % (self.rootTypeVarName, sTypeAccess))
518 self.cgen.endIf()
520 if self.direction == "read" and self.dynAlloc:
521 self.cgen.stmt("size_t %s" % sizeVar)
522 self.cgen.stmt("%s = %s->getBe32()" % \
523 (sizeVar, self.streamVarName))
524 self.cgen.stmt("%s = nullptr" % access)
525 self.cgen.beginIf(sizeVar)
526 self.cgen.stmt( \
528 (self.streamVarName, access))
530 self.genStreamCall(vulkanType, access, "sizeof(VkStructureType)")
531 self.cgen.stmt("VkStructureType extType = *(VkStructureType*)(%s)" % access)
532 self.cgen.stmt( \
534 …(self.streamVarName, access, EXTENSION_SIZE_WITH_STREAM_FEATURES_API_NAME, self.streamVarName, sel…
535 self.cgen.stmt("*(VkStructureType*)%s = extType" % access)
537 self.cgen.funcCall(None, self.marshalPrefix + "extension_struct",
538 [self.streamVarName, self.rootTypeVarName, castedAccessExpr])
539 self.cgen.endIf()
542 self.cgen.funcCall(None, self.marshalPrefix + "extension_struct",
543 [self.streamVarName, self.rootTypeVarName, castedAccessExpr])
546 def onPointer(self, vulkanType): argument
547 access = self.exprAccessor(vulkanType)
549 lenAccess = self.lenAccessor(vulkanType)
550 lenAccessGuard = self.lenAccessorGuard(vulkanType)
552 self.beginFilterGuard(vulkanType)
553 self.doAllocSpace(vulkanType)
558 if vulkanType.isHandleType() and self.mapHandles:
559 self.genHandleMappingCall(vulkanType, access, lenAccess)
561 if self.typeInfo.isNonAbiPortableType(vulkanType.typeName):
564 self.cgen.beginIf(lenAccessGuard)
565 self.cgen.beginFor("uint32_t i = 0", "i < (uint32_t)%s" % lenAccess, "++i")
566 self.genPrimitiveStreamCall(vulkanType.getForValueAccess(), "%s[i]" % access)
567 self.cgen.endFor()
569 self.cgen.endIf()
571 self.genPrimitiveStreamCall(vulkanType.getForValueAccess(), "(*%s)" % access)
575 lenAccess, self.cgen.sizeofExpr(vulkanType.getForValueAccess()))
578 self.cgen.sizeofExpr(vulkanType.getForValueAccess()))
579 self.genStreamCall(vulkanType, access, finalLenExpr)
581 if self.direction == "read":
582 self.endFilterGuard(vulkanType, "%s = 0" % access)
584 self.endFilterGuard(vulkanType)
586 def onValue(self, vulkanType): argument
587 self.beginFilterGuard(vulkanType)
589 if vulkanType.isHandleType() and self.mapHandles:
590 access = self.exprAccessor(vulkanType)
593 self.genHandleMappingCall(
595 elif self.typeInfo.isNonAbiPortableType(vulkanType.typeName):
596 access = self.exprPrimitiveValueAccessor(vulkanType)
597 self.genPrimitiveStreamCall(vulkanType, access)
599 access = self.exprAccessor(vulkanType)
600 self.genStreamCall(vulkanType, access, self.cgen.sizeofExpr(vulkanType))
602 self.endFilterGuard(vulkanType)
604 def streamLetParameter(self, structInfo, letParamInfo): argument
605 …filterFeature = "%s->getFeatureBits() & VULKAN_STREAM_FEATURE_IGNORED_HANDLES_BIT" % self.streamVa…
606 self.cgen.stmt("%s %s = 1" % (letParamInfo.typeName, letParamInfo.paramName))
608 self.cgen.beginIf(filterFeature)
610 if self.direction == "write":
611 bodyExpr = self.currentStructInfo.environment[letParamInfo.paramName]["body"]
612 …self.cgen.stmt("%s = %s" % (letParamInfo.paramName, self.genFilterFunc(bodyExpr, self.currentStruc…
614 self.genPrimitiveStreamCall(letParamInfo, letParamInfo.paramName)
616 self.cgen.endIf()
621 def __init__(self, module, typeInfo, variant="host"): argument
622 VulkanWrapperGenerator.__init__(self, module, typeInfo)
624 self.cgenHeader = CodeGen()
625 self.cgenImpl = CodeGen()
627 self.variant = variant
629 self.currentFeature = None
630 self.apiOpcodes = {}
631 self.dynAlloc = self.variant != "guest"
633 if self.variant == "guest":
634 self.marshalingParams = PARAMETERS_MARSHALING_GUEST
636 self.marshalingParams = PARAMETERS_MARSHALING
638 self.writeCodegen = \
647 self.readCodegen = \
655 dynAlloc=self.dynAlloc)
657 self.knownDefs = {}
662 self.beginOpcodeOld = 20000
663 self.endOpcodeOld = 30000
665 self.beginOpcode = 200000000
666 self.endOpcode = 300000000
667 self.knownOpcodes = set()
669 self.extensionMarshalPrototype = \
672 self.marshalingParams +
675 self.extensionUnmarshalPrototype = \
678 self.marshalingParams +
681 def onBegin(self,): argument
682 VulkanWrapperGenerator.onBegin(self)
683 self.module.appendImpl(self.cgenImpl.makeFuncDecl(self.extensionMarshalPrototype))
684 self.module.appendImpl(self.cgenImpl.makeFuncDecl(self.extensionUnmarshalPrototype))
686 def onBeginFeature(self, featureName): argument
687 VulkanWrapperGenerator.onBeginFeature(self, featureName)
688 self.currentFeature = featureName
690 def onGenType(self, typeXml, name, alias): argument
691 VulkanWrapperGenerator.onGenType(self, typeXml, name, alias)
693 if name in self.knownDefs:
696 category = self.typeInfo.categoryOf(name)
699 self.module.appendHeader(
700 self.cgenHeader.makeFuncAlias(API_PREFIX_MARSHAL + name,
702 self.module.appendHeader(
703 self.cgenHeader.makeFuncAlias(API_PREFIX_UNMARSHAL + name,
708 structInfo = self.typeInfo.structs[name]
710 marshalParams = self.marshalingParams + \
734 self.writeCodegen.cgen = cgen
735 self.writeCodegen.currentStructInfo = structInfo
736 self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
741 streamVarName=self.writeCodegen.streamVarName,
742 rootTypeVarName=self.writeCodegen.rootTypeVarName,
743 inputVarName=self.writeCodegen.inputVarName,
744 newInputVarName=self.writeCodegen.inputVarName + "_new")
749 self.writeCodegen.cgen = cgen
750 self.writeCodegen.currentStructInfo = structInfo
751 self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
756 self.writeCodegen.streamLetParameter(self.typeInfo, letp)
759 iterateVulkanType(self.typeInfo, member, self.writeCodegen)
761 iterateVulkanType(self.typeInfo, structInfo.members[0], self.writeCodegen)
764 self.writeCodegen.cgen = cgen
765 self.writeCodegen.currentStructInfo = structInfo
766 self.writeCodegen.doFiltering = False
767 self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
772 self.writeCodegen.streamLetParameter(self.typeInfo, letp)
775 iterateVulkanType(self.typeInfo, member, self.writeCodegen)
777 iterateVulkanType(self.typeInfo, structInfo.members[0], self.writeCodegen)
778 self.writeCodegen.doFiltering = True
780 self.module.appendHeader(
781 self.cgenHeader.makeFuncDecl(marshalPrototype))
784 self.module.appendImpl(
785 self.cgenImpl.makeFuncImpl(
788 self.module.appendImpl(
789 self.cgenImpl.makeFuncImpl(
793 self.module.appendHeader(
794 self.cgenHeader.makeFuncDecl(marshalPrototypeNoFilter))
795 self.module.appendImpl(
796 self.cgenImpl.makeFuncImpl(
802 …self.marshalingParams + [makeVulkanTypeSimple(False, name, 1, UNMARSHAL_INPUT_VAR_NAME)] + freePar…
807 … self.marshalingParams + [makeVulkanTypeSimple(False, name, 1, UNMARSHAL_INPUT_VAR_NAME)])
810 self.readCodegen.cgen = cgen
811 self.readCodegen.currentStructInfo = structInfo
812 self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
817 streamVarName=self.readCodegen.streamVarName,
818 rootTypeVarName=self.readCodegen.rootTypeVarName,
819 inputVarName=self.readCodegen.inputVarName,
820 newInputVarName=self.readCodegen.inputVarName + "_new")
825 self.readCodegen.cgen = cgen
826 self.readCodegen.currentStructInfo = structInfo
827 self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
832 self.readCodegen.streamLetParameter(self.typeInfo, letp)
835 iterateVulkanType(self.typeInfo, member, self.readCodegen)
837 iterateVulkanType(self.typeInfo, structInfo.members[0], self.readCodegen)
840 self.readCodegen.cgen = cgen
841 self.readCodegen.currentStructInfo = structInfo
842 self.readCodegen.doFiltering = False
843 self.writeCodegen.cgen.stmt("(void)%s" % ROOT_TYPE_VAR_NAME)
848 iterateVulkanType(self.typeInfo, letp, self.readCodegen)
850 iterateVulkanType(self.typeInfo, member, self.readCodegen)
852 iterateVulkanType(self.typeInfo, structInfo.members[0], self.readCodegen)
853 self.readCodegen.doFiltering = True
855 self.module.appendHeader(
856 self.cgenHeader.makeFuncDecl(unmarshalPrototype))
859 self.module.appendImpl(
860 self.cgenImpl.makeFuncImpl(
863 self.module.appendImpl(
864 self.cgenImpl.makeFuncImpl(
868 self.module.appendHeader(
869 self.cgenHeader.makeFuncDecl(unmarshalPrototypeNoFilter))
870 self.module.appendImpl(
871 self.cgenImpl.makeFuncImpl(
874 def onGenCmd(self, cmdinfo, name, alias): argument
875 VulkanWrapperGenerator.onGenCmd(self, cmdinfo, name, alias)
881 opcode = self.beginOpcode + hashInt % (self.endOpcode - self.beginOpcode)
883 while opcode in self.knownOpcodes:
893 self.module.appendHeader(
895 self.apiOpcodes[name] = (opcode, self.currentFeature)
896 self.knownOpcodes.add(opcode)
898 …def doExtensionStructMarshalingCodegen(self, cgen, retType, extParam, forEach, funcproto, directio… argument
919 elif not self.dynAlloc:
932 elif not self.dynAlloc:
943 self.emitForEachStructExtension(
951 def onEnd(self,): argument
952 VulkanWrapperGenerator.onEnd(self)
962 self.module.appendImpl(
963 self.cgenImpl.makeFuncImpl(
964 self.extensionMarshalPrototype,
965 lambda cgen: self.doExtensionStructMarshalingCodegen(
970 self.extensionMarshalPrototype,
973 self.module.appendImpl(
974 self.cgenImpl.makeFuncImpl(
975 self.extensionUnmarshalPrototype,
976 lambda cgen: self.doExtensionStructMarshalingCodegen(
981 self.extensionUnmarshalPrototype,
989 self.module.appendHeader(
990 self.cgenHeader.makeFuncDecl(opcode2stringPrototype))
1023 self.module.appendImpl(
1024 self.cgenImpl.makeFuncImpl(
1026 lambda cgen: emitOpcode2StringImpl(self.apiOpcodes, cgen)))
1028 self.module.appendHeader(
1029 "#define OP_vkFirst_old %d\n" % (self.beginOpcodeOld))
1030 self.module.appendHeader(
1031 "#define OP_vkLast_old %d\n" % (self.endOpcodeOld))
1032 self.module.appendHeader(
1033 "#define OP_vkFirst %d\n" % (self.beginOpcode))
1034 self.module.appendHeader(
1035 "#define OP_vkLast %d\n" % (self.endOpcode))