Blame - generator.py - platform/external/vulkan-validation-layers

2016-05-10 16:44:16 -0600

[diff] [blame]

1976

asciidoc += ' must: be `NULL`'

1977

if validextensionstructs is not None:

1978

extensionstructs = ['slink:' + x for x in validextensionstructs.split(',')]

1979

asciidoc += ', or a pointer to a valid instance of '

1980

if len(extensionstructs) == 1:

1981

asciidoc += validextensionstructs

1982

else:

1983

asciidoc += (', ').join(extensionstructs[:-1]) + ' or ' + extensionstructs[-1]

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

asciidoc += '\n'

return asciidoc

#

# Generate all the valid usage information for a given struct or command

1991

def makeValidUsageStatements(self, cmd, blockname, params, usages):

1992

# Start the asciidoc block for this

asciidoc = ''

handles = []

anyparentedhandlesoptional = False

1997

parentdictionary = {}

1998

arraylengths = set()

1999

for param in params:

2000

paramname = param.find('name')

2001

paramtype = param.find('type')

2002

2003

# Get the type's category

2004

typecategory = self.getTypeCategory(paramtype.text)

2005

2006

# Generate language to independently validate a parameter

2007

if paramtype.text == 'VkStructureType' and paramname.text == 'sType':

2008

asciidoc += self.makeStructureType(blockname, param)

2009

elif paramtype.text == 'void' and paramname.text == 'pNext':

2010

asciidoc += self.makeStructureExtensionPointer(param)

2011

else:

2012

asciidoc += self.createValidationLineForParameter(param, params, typecategory)

2013

2014

# Ensure that any parenting is properly validated, and list that a handle was found

2015

if typecategory == 'handle':

2016

# Don't detect a parent for return values!

2017

if not self.paramIsPointer(param) or (param.text is not None and 'const' in param.text):

2018

parent = self.getHandleParent(paramtype.text)

2019

if parent is not None:

2020

handles.append(param)

2021

2022

# If any param is optional, it affects the output

2023

if self.isHandleOptional(param, params):

2024

anyparentedhandlesoptional = True

2025

2026

# Find the first dispatchable parent

2027

ancestor = parent

2028

while ancestor is not None and not self.isHandleTypeDispatchable(ancestor):

2029

ancestor = self.getHandleParent(ancestor)

2030

2031

# If one was found, add this parameter to the parent dictionary

2032

if ancestor is not None:

2033

if ancestor not in parentdictionary:

2034

parentdictionary[ancestor] = []

2035

2036

if self.paramIsArray(param):

2037

parentdictionary[ancestor].append('the elements of ' + self.makeParameterName(paramname.text))

2038

else:

2039

parentdictionary[ancestor].append(self.makeParameterName(paramname.text))

2040

2041

# Get the array length for this parameter

2042

arraylength = param.attrib.get('len')

2043

if arraylength is not None:

2044

for onelength in arraylength.split(','):

2045

arraylengths.add(onelength)

2046

2047

# For any vkQueue* functions, there might be queue type data

2048

if 'vkQueue' in blockname:

2049

# The queue type must be valid

2050

queuetypes = cmd.attrib.get('queues')

2051

if queuetypes is not None:

2052

queuebits = []

2053

for queuetype in re.findall(r'([^,]+)', queuetypes):

2054

queuebits.append(queuetype.replace('_',' '))

2055

2056

asciidoc += '* '

2057

asciidoc += 'The pname:queue must: support '

2058

if len(queuebits) == 1:

2059

asciidoc += queuebits[0]

2060

else:

2061

asciidoc += (', ').join(queuebits[:-1])

2062

asciidoc += ' or '

2063

asciidoc += queuebits[-1]

2064

asciidoc += ' operations'

2065

asciidoc += '\n'

2066

2067

if 'vkCmd' in blockname:

2068

# The commandBuffer parameter must be being recorded

2069

asciidoc += '* '

2070

asciidoc += 'pname:commandBuffer must: be in the recording state'

2071

asciidoc += '\n'

2072

2073

# The queue type must be valid

2074

queuetypes = cmd.attrib.get('queues')

2075

queuebits = []

2076

for queuetype in re.findall(r'([^,]+)', queuetypes):

2077

queuebits.append(queuetype.replace('_',' '))

2078

2079

asciidoc += '* '

2080

asciidoc += 'The sname:VkCommandPool that pname:commandBuffer was allocated from must: support '

2081

if len(queuebits) == 1:

2082

asciidoc += queuebits[0]

2083

else:

2084

asciidoc += (', ').join(queuebits[:-1])

2085

asciidoc += ' or '

2086

asciidoc += queuebits[-1]

2087

asciidoc += ' operations'

2088

asciidoc += '\n'

2089

2090

# Must be called inside/outside a renderpass appropriately

2091

renderpass = cmd.attrib.get('renderpass')

2092

2093

if renderpass != 'both':

2094

asciidoc += '* This command must: only be called '

2095

asciidoc += renderpass

2096

asciidoc += ' of a render pass instance'

2097

asciidoc += '\n'

2098

2099

# Must be in the right level command buffer

2100

cmdbufferlevel = cmd.attrib.get('cmdbufferlevel')

2101

2102

if cmdbufferlevel != 'primary,secondary':

2103

asciidoc += '* pname:commandBuffer must: be a '

2104

asciidoc += cmdbufferlevel

2105

asciidoc += ' sname:VkCommandBuffer'

2106

asciidoc += '\n'

2107

2108

# Any non-optional arraylengths should specify they must be greater than 0

2109

for param in params:

2110

paramname = param.find('name')

2111

2112

for arraylength in arraylengths:

2113

if paramname.text == arraylength and param.attrib.get('optional') is None:

2114

# Get all the array dependencies

2115

arrays = cmd.findall("param/[@len='" + arraylength + "'][@optional='true']")

2116

2117

# Get all the optional array dependencies, including those not generating validity for some reason

2118

optionalarrays = cmd.findall("param/[@len='" + arraylength + "'][@optional='true']")

2119

optionalarrays.extend(cmd.findall("param/[@len='" + arraylength + "'][@noautovalidity='true']"))

asciidoc += '* '

# Allow lengths to be arbitrary if all their dependents are optional

2124

if len(optionalarrays) == len(arrays) and len(optionalarrays) != 0:

2125

asciidoc += 'If '

2126

if len(optionalarrays) > 1:

2127

asciidoc += 'any of '

2128

2129

for array in optionalarrays[:-1]:

2130

asciidoc += self.makeParameterName(optionalarrays.find('name').text)

2131

asciidoc += ', '

2132

2133

if len(optionalarrays) > 1:

2134

asciidoc += 'and '

2135

asciidoc += self.makeParameterName(optionalarrays[-1].find('name').text)

2136

asciidoc += ' are '

2137

else:

2138

asciidoc += self.makeParameterName(optionalarrays[-1].find('name').text)

2139

asciidoc += ' is '

2140

2141

asciidoc += 'not `NULL`, '

2142

2143

if self.paramIsPointer(param):

2144

asciidoc += 'the value referenced by '

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2145

2146

elif self.paramIsPointer(param):

2147

asciidoc += 'The value referenced by '

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2148

2149

asciidoc += self.makeParameterName(arraylength)

2150

asciidoc += ' must: be greater than `0`'

2151

asciidoc += '\n'

2152

2153

# Find the parents of all objects referenced in this command

2154

for param in handles:

2155

asciidoc += self.makeAsciiDocHandleParent(param, params)

2156

2157

# Find the common ancestors of objects

2158

noancestorscount = 0

2159

while noancestorscount < len(parentdictionary):

2160

noancestorscount = 0

2161

oldparentdictionary = parentdictionary.copy()

2162

for parent in oldparentdictionary.items():

2163

ancestor = self.getHandleParent(parent[0])

2164

2165

while ancestor is not None and ancestor not in parentdictionary:

2166

ancestor = self.getHandleParent(ancestor)

2167

2168

if ancestor is not None:

2169

parentdictionary[ancestor] += parentdictionary.pop(parent[0])

2170

else:

2171

# No ancestors possible - so count it up

2172

noancestorscount += 1

2173

2174

# Add validation language about common ancestors

2175

for parent in parentdictionary.items():

2176

if len(parent[1]) > 1:

2177

parentlanguage = '* '

2178

2179

parentlanguage += 'Each of '

2180

parentlanguage += ", ".join(parent[1][:-1])

2181

parentlanguage += ' and '

2182

parentlanguage += parent[1][-1]

2183

if anyparentedhandlesoptional is True:

2184

parentlanguage += ' that are valid handles'

2185

parentlanguage += ' must: have been created, allocated or retrieved from the same '

2186

parentlanguage += self.makeStructName(parent[0])

2187

parentlanguage += '\n'

2188

2189

# Capitalize and add to the main language

2190

asciidoc += parentlanguage

2191

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2192

# Add in any plain-text validation language that should be added

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2193

for usage in usages:

2194

asciidoc += '* '

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2195

asciidoc += usage

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2196

asciidoc += '\n'

2197

2198

# In case there's nothing to report, return None

2199

if asciidoc == '':

2200

return None

2201

# Delimit the asciidoc block

2202

return asciidoc

2203

2204

def makeThreadSafetyBlock(self, cmd, paramtext):

2205

"""Generate C function pointer typedef for <command> Element"""

2206

paramdecl = ''

2207

2208

# For any vkCmd* functions, the commandBuffer parameter must be being recorded

2209

if cmd.find('proto/name') is not None and 'vkCmd' in cmd.find('proto/name'):

2210

paramdecl += '* '

2211

paramdecl += 'The sname:VkCommandPool that pname:commandBuffer was created from'

2212

paramdecl += '\n'

2213

2214

# Find and add any parameters that are thread unsafe

2215

explicitexternsyncparams = cmd.findall(paramtext + "[@externsync]")

2216

if (explicitexternsyncparams is not None):

2217

for param in explicitexternsyncparams:

2218

externsyncattribs = param.attrib.get('externsync')

2219

paramname = param.find('name')

2220

for externsyncattrib in externsyncattribs.split(','):

2221

paramdecl += '* '

2222

paramdecl += 'Host access to '

2223

if externsyncattrib == 'true':

2224

if self.paramIsArray(param):

2225

paramdecl += 'each member of ' + self.makeParameterName(paramname.text)

2226

elif self.paramIsPointer(param):

2227

paramdecl += 'the object referenced by ' + self.makeParameterName(paramname.text)

2228

else:

2229

paramdecl += self.makeParameterName(paramname.text)

2230

else:

2231

paramdecl += 'pname:'

2232

paramdecl += externsyncattrib

2233

paramdecl += ' must: be externally synchronized\n'

2234

2235

# Find and add any "implicit" parameters that are thread unsafe

2236

implicitexternsyncparams = cmd.find('implicitexternsyncparams')

2237

if (implicitexternsyncparams is not None):

2238

for elem in implicitexternsyncparams:

2239

paramdecl += '* '

2240

paramdecl += 'Host access to '

2241

paramdecl += elem.text

2242

paramdecl += ' must: be externally synchronized\n'

2243

2244

if (paramdecl == ''):

return None

else:

return paramdecl

def makeCommandPropertiesTableEntry(self, cmd, name):

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2250

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2251

if 'vkCmd' in name:

2252

# Must be called inside/outside a renderpass appropriately

2253

cmdbufferlevel = cmd.attrib.get('cmdbufferlevel')

2254

cmdbufferlevel = (' + \n').join(cmdbufferlevel.title().split(','))

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2255

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2256

renderpass = cmd.attrib.get('renderpass')

2257

renderpass = renderpass.capitalize()

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2258

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2259

queues = cmd.attrib.get('queues')

2260

queues = (' + \n').join(queues.upper().split(','))

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2261

2262

return '|' + cmdbufferlevel + '|' + renderpass + '|' + queues

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2263

elif 'vkQueue' in name:

2264

# Must be called inside/outside a renderpass appropriately

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2265

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2266

queues = cmd.attrib.get('queues')

if queues is None:

queues = 'Any'

else:

queues = (' + \n').join(queues.upper().split(','))

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2271

2272

return '|-|-|' + queues

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2273

2274

return None

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2275

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2276

def makeSuccessCodes(self, cmd, name):

2277

2278

successcodes = cmd.attrib.get('successcodes')

2279

if successcodes is not None:

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2280

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2281

successcodeentry = ''

2282

successcodes = successcodes.split(',')

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2283

return '* ename:' + '\n* ename:'.join(successcodes)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

return None

def makeErrorCodes(self, cmd, name):

2288

2289

errorcodes = cmd.attrib.get('errorcodes')

2290

if errorcodes is not None:

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2291

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2292

errorcodeentry = ''

2293

errorcodes = errorcodes.split(',')

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2294

return '* ename:' + '\n* ename:'.join(errorcodes)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

return None

#

# Command generation

def genCmd(self, cmdinfo, name):

2301

OutputGenerator.genCmd(self, cmdinfo, name)

2302

#

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2303

# Get all the parameters

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2304

params = cmdinfo.elem.findall('param')

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2305

usageelements = cmdinfo.elem.findall('validity/usage')

2306

usages = []

2307

2308

for usage in usageelements:

2309

usages.append(usage.text)

2310

for usage in cmdinfo.additionalValidity:

2311

usages.append(usage.text)

2312

for usage in cmdinfo.removedValidity:

2313

usages.remove(usage.text)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2314

2315

validity = self.makeValidUsageStatements(cmdinfo.elem, name, params, usages)

2316

threadsafety = self.makeThreadSafetyBlock(cmdinfo.elem, 'param')

2317

commandpropertiesentry = self.makeCommandPropertiesTableEntry(cmdinfo.elem, name)

2318

successcodes = self.makeSuccessCodes(cmdinfo.elem, name)

2319

errorcodes = self.makeErrorCodes(cmdinfo.elem, name)

2320

2321

self.writeInclude('validity/protos', name, validity, threadsafety, commandpropertiesentry, successcodes, errorcodes)

#

# Struct Generation

def genStruct(self, typeinfo, typename):

2326

OutputGenerator.genStruct(self, typeinfo, typename)

2327

2328

# Anything that's only ever returned can't be set by the user, so shouldn't have any validity information.

2329

if typeinfo.elem.attrib.get('returnedonly') is None:

2330

params = typeinfo.elem.findall('member')

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2331

2332

usageelements = typeinfo.elem.findall('validity/usage')

2333

usages = []

2334

2335

for usage in usageelements:

2336

usages.append(usage.text)

2337

for usage in typeinfo.additionalValidity:

2338

usages.append(usage.text)

2339

for usage in typeinfo.removedValidity:

2340

usages.remove(usage.text)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2341

2342

validity = self.makeValidUsageStatements(typeinfo.elem, typename, params, usages)

2343

threadsafety = self.makeThreadSafetyBlock(typeinfo.elem, 'member')

2344

2345

self.writeInclude('validity/structs', typename, validity, threadsafety, None, None, None)

2346

else:

2347

# Still generate files for return only structs, in case this state changes later

2348

self.writeInclude('validity/structs', typename, None, None, None, None, None)

#

# Type Generation

def genType(self, typeinfo, typename):

2353

OutputGenerator.genType(self, typeinfo, typename)

2354

2355

category = typeinfo.elem.get('category')

2356

if (category == 'struct' or category == 'union'):

2357

self.genStruct(typeinfo, typename)

2358

2359

# HostSynchronizationOutputGenerator - subclass of OutputGenerator.

2360

# Generates AsciiDoc includes of the externsync parameter table for the

2361

# fundamentals chapter of the Vulkan specification. Similar to

2362

# DocOutputGenerator.

2363

#

2364

# ---- methods ----

2365

# HostSynchronizationOutputGenerator(errFile, warnFile, diagFile) - args as for

2366

# OutputGenerator. Defines additional internal state.

2367

# ---- methods overriding base class ----

2368

# genCmd(cmdinfo)

2369

class HostSynchronizationOutputGenerator(OutputGenerator):

2370

# Generate Host Synchronized Parameters in a table at the top of the spec

2371

def __init__(self,

2372

errFile = sys.stderr,

2373

warnFile = sys.stderr,

2374

diagFile = sys.stdout):

2375

OutputGenerator.__init__(self, errFile, warnFile, diagFile)

2376

2377

threadsafety = {'parameters': '', 'parameterlists': '', 'implicit': ''}

2378

2379

def makeParameterName(self, name):

2380

return 'pname:' + name

2381

2382

def makeFLink(self, name):

2383

return 'flink:' + name

2384

2385

#

2386

# Generate an include file

2387

#

2388

# directory - subdirectory to put file in

2389

# basename - base name of the file

2390

# contents - contents of the file (Asciidoc boilerplate aside)

2391

def writeInclude(self):

2392

2393

if self.threadsafety['parameters'] is not None:

2394

# Create file

2395

filename = self.genOpts.genDirectory + '/' + self.genOpts.filename + '/parameters.txt'

2396

self.logMsg('diag', '# Generating include file:', filename)

2397

fp = open(filename, 'w')

2398

2399

# Host Synchronization

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2400

write('// WARNING: DO NOT MODIFY! This file is automatically generated from the vk.xml registry', file=fp)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2401

write('.Externally Synchronized Parameters', file=fp)

2402

write('*' * 80, file=fp)

2403

write(self.threadsafety['parameters'], file=fp, end='')

2404

write('*' * 80, file=fp)

2405

write('', file=fp)

2406

2407

if self.threadsafety['parameterlists'] is not None:

2408

# Create file

2409

filename = self.genOpts.genDirectory + '/' + self.genOpts.filename + '/parameterlists.txt'

2410

self.logMsg('diag', '# Generating include file:', filename)

2411

fp = open(filename, 'w')

2412

2413

# Host Synchronization

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2414

write('// WARNING: DO NOT MODIFY! This file is automatically generated from the vk.xml registry', file=fp)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2415

write('.Externally Synchronized Parameter Lists', file=fp)

2416

write('*' * 80, file=fp)

2417

write(self.threadsafety['parameterlists'], file=fp, end='')

2418

write('*' * 80, file=fp)

2419

write('', file=fp)

2420

2421

if self.threadsafety['implicit'] is not None:

2422

# Create file

2423

filename = self.genOpts.genDirectory + '/' + self.genOpts.filename + '/implicit.txt'

2424

self.logMsg('diag', '# Generating include file:', filename)

2425

fp = open(filename, 'w')

2426

2427

# Host Synchronization

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

2428

write('// WARNING: DO NOT MODIFY! This file is automatically generated from the vk.xml registry', file=fp)

Mike Stroyan

2016-01-07 15:35:37 -0700

[diff] [blame]

2429

write('.Implicit Externally Synchronized Parameters', file=fp)

2430

write('*' * 80, file=fp)

2431

write(self.threadsafety['implicit'], file=fp, end='')

2432

write('*' * 80, file=fp)

write('', file=fp)

fp.close()

#

# Check if the parameter passed in is a pointer to an array

2439

def paramIsArray(self, param):

2440

return param.attrib.get('len') is not None

2441

2442

# Check if the parameter passed in is a pointer

2443

def paramIsPointer(self, param):

2444

ispointer = False

2445

paramtype = param.find('type')

2446

if paramtype.tail is not None and '*' in paramtype.tail:

ispointer = True

return ispointer

# Turn the "name[].member[]" notation into plain English.

2452

def makeThreadDereferenceHumanReadable(self, dereference):

2453

matches = re.findall(r"[\w]+[^\w]*",dereference)

2454

stringval = ''

2455

for match in reversed(matches):

2456

if '->' in match or '.' in match:

2457

stringval += 'member of '

2458

if '[]' in match:

2459

stringval += 'each element of '

2460

2461

stringval += 'the '

2462

stringval += self.makeParameterName(re.findall(r"[\w]+",match)[0])

2463

stringval += ' '

2464

2465

stringval += 'parameter'

2466

2467

return stringval[0].upper() + stringval[1:]

2468

2469

def makeThreadSafetyBlocks(self, cmd, paramtext):

2470

protoname = cmd.find('proto/name').text

2471

2472

# Find and add any parameters that are thread unsafe

2473

explicitexternsyncparams = cmd.findall(paramtext + "[@externsync]")

2474

if (explicitexternsyncparams is not None):

2475

for param in explicitexternsyncparams:

2476

externsyncattribs = param.attrib.get('externsync')

2477

paramname = param.find('name')

2478

for externsyncattrib in externsyncattribs.split(','):

2479

2480

tempstring = '* '

2481

if externsyncattrib == 'true':

2482

if self.paramIsArray(param):

2483

tempstring += 'Each element of the '

2484

elif self.paramIsPointer(param):

2485

tempstring += 'The object referenced by the '

else:

tempstring += 'The '

tempstring += self.makeParameterName(paramname.text)

2490

tempstring += ' parameter'

2491

2492

else:

2493

tempstring += self.makeThreadDereferenceHumanReadable(externsyncattrib)

2494

2495

tempstring += ' in '

2496

tempstring += self.makeFLink(protoname)

tempstring += '\n'

if ' element of ' in tempstring:

2501

self.threadsafety['parameterlists'] += tempstring

2502

else:

2503

self.threadsafety['parameters'] += tempstring

2504

2505

2506

# Find and add any "implicit" parameters that are thread unsafe

2507

implicitexternsyncparams = cmd.find('implicitexternsyncparams')

2508

if (implicitexternsyncparams is not None):

2509

for elem in implicitexternsyncparams:

2510

self.threadsafety['implicit'] += '* '

2511

self.threadsafety['implicit'] += elem.text[0].upper()

2512

self.threadsafety['implicit'] += elem.text[1:]

2513

self.threadsafety['implicit'] += ' in '

2514

self.threadsafety['implicit'] += self.makeFLink(protoname)

2515

self.threadsafety['implicit'] += '\n'

2516

2517

2518

# For any vkCmd* functions, the commandBuffer parameter must be being recorded

2519

if protoname is not None and 'vkCmd' in protoname:

2520

self.threadsafety['implicit'] += '* '

2521

self.threadsafety['implicit'] += 'The sname:VkCommandPool that pname:commandBuffer was allocated from, in '

2522

self.threadsafety['implicit'] += self.makeFLink(protoname)

2523

2524

self.threadsafety['implicit'] += '\n'

#

# Command generation

def genCmd(self, cmdinfo, name):

2529

OutputGenerator.genCmd(self, cmdinfo, name)

2530

#

2531

# Get all thh parameters

2532

params = cmdinfo.elem.findall('param')

2533

usages = cmdinfo.elem.findall('validity/usage')

2534

2535

self.makeThreadSafetyBlocks(cmdinfo.elem, 'param')

2536

2537

self.writeInclude()

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2538

2539

# ThreadOutputGenerator - subclass of OutputGenerator.

2540

# Generates Thread checking framework

2541

#

2542

# ---- methods ----

2543

# ThreadOutputGenerator(errFile, warnFile, diagFile) - args as for

2544

# OutputGenerator. Defines additional internal state.

2545

# ---- methods overriding base class ----

2546

# beginFile(genOpts)

2547

# endFile()

2548

# beginFeature(interface, emit)

2549

# endFeature()

2550

# genType(typeinfo,name)

2551

# genStruct(typeinfo,name)

2552

# genGroup(groupinfo,name)

2553

# genEnum(enuminfo, name)

2554

# genCmd(cmdinfo)

2555

class ThreadOutputGenerator(OutputGenerator):

2556

"""Generate specified API interfaces in a specific style, such as a C header"""

2557

# This is an ordered list of sections in the header file.

2558

TYPE_SECTIONS = ['include', 'define', 'basetype', 'handle', 'enum',

2559

'group', 'bitmask', 'funcpointer', 'struct']

2560

ALL_SECTIONS = TYPE_SECTIONS + ['command']

2561

def __init__(self,

2562

errFile = sys.stderr,

2563

warnFile = sys.stderr,

2564

diagFile = sys.stdout):

2565

OutputGenerator.__init__(self, errFile, warnFile, diagFile)

2566

# Internal state - accumulators for different inner block text

2567

self.sections = dict([(section, []) for section in self.ALL_SECTIONS])

2568

self.intercepts = []

2569

2570

# Check if the parameter passed in is a pointer to an array

2571

def paramIsArray(self, param):

2572

return param.attrib.get('len') is not None

2573

2574

# Check if the parameter passed in is a pointer

2575

def paramIsPointer(self, param):

2576

ispointer = False

2577

for elem in param:

2578

#write('paramIsPointer '+elem.text, file=sys.stderr)

2579

#write('elem.tag '+elem.tag, file=sys.stderr)

2580

#if (elem.tail is None):

2581

# write('elem.tail is None', file=sys.stderr)

2582

#else:

2583

# write('elem.tail '+elem.tail, file=sys.stderr)

2584

if ((elem.tag is not 'type') and (elem.tail is not None)) and '*' in elem.tail:

2585

ispointer = True

2586

# write('is pointer', file=sys.stderr)

2587

return ispointer

2588

def makeThreadUseBlock(self, cmd, functionprefix):

2589

"""Generate C function pointer typedef for <command> Element"""

2590

paramdecl = ''

2591

thread_check_dispatchable_objects = [

"VkCommandBuffer",

"VkDevice",

"VkInstance",

"VkQueue",

]

thread_check_nondispatchable_objects = [

"VkBuffer",

"VkBufferView",

"VkCommandPool",

"VkDescriptorPool",

"VkDescriptorSetLayout",

"VkDeviceMemory",

"VkEvent",

"VkFence",

"VkFramebuffer",

"VkImage",

"VkImageView",

"VkPipeline",

"VkPipelineCache",

"VkPipelineLayout",

"VkQueryPool",

"VkRenderPass",

"VkSampler",

"VkSemaphore",

"VkShaderModule",

]

# Find and add any parameters that are thread unsafe

2620

params = cmd.findall('param')

2621

for param in params:

2622

paramname = param.find('name')

2623

if False: # self.paramIsPointer(param):

2624

paramdecl += ' // not watching use of pointer ' + paramname.text + '\n'

2625

else:

2626

externsync = param.attrib.get('externsync')

2627

if externsync == 'true':

2628

if self.paramIsArray(param):

Michael Mc Donnell

c133bd0

2016-03-17 21:18:32 -0700

[diff] [blame]

2629

paramdecl += ' for (uint32_t index=0;index<' + param.attrib.get('len') + ';index++) {\n'

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2630

paramdecl += ' ' + functionprefix + 'WriteObject(my_data, ' + paramname.text + '[index]);\n'

2631

paramdecl += ' }\n'

2632

else:

2633

paramdecl += ' ' + functionprefix + 'WriteObject(my_data, ' + paramname.text + ');\n'

2634

elif (param.attrib.get('externsync')):

2635

if self.paramIsArray(param):

2636

# Externsync can list pointers to arrays of members to synchronize

Michael Mc Donnell

c133bd0

2016-03-17 21:18:32 -0700

[diff] [blame]

2637

paramdecl += ' for (uint32_t index=0;index<' + param.attrib.get('len') + ';index++) {\n'

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2638

for member in externsync.split(","):

2639

# Replace first empty [] in member name with index

2640

element = member.replace('[]','[index]',1)

2641

if '[]' in element:

2642

# Replace any second empty [] in element name with

2643

# inner array index based on mapping array names like

2644

# "pSomeThings[]" to "someThingCount" array size.

2645

# This could be more robust by mapping a param member

2646

# name to a struct type and "len" attribute.

2647

limit = element[0:element.find('s[]')] + 'Count'

2648

dotp = limit.rfind('.p')

2649

limit = limit[0:dotp+1] + limit[dotp+2:dotp+3].lower() + limit[dotp+3:]

Mike Stroyan

2016-07-13 10:10:25 -0600

[diff] [blame]

2650

paramdecl += ' for(uint32_t index2=0;index2<'+limit+';index2++)\n'

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2651

element = element.replace('[]','[index2]')

Mike Stroyan

2016-07-13 10:10:25 -0600

[diff] [blame]

2652

paramdecl += ' ' + functionprefix + 'WriteObject(my_data, ' + element + ');\n'

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2653

paramdecl += ' }\n'

2654

else:

2655

# externsync can list members to synchronize

2656

for member in externsync.split(","):

Mark Lobodzinski

3b34af0

2016-09-27 13:08:15 -0600

[diff] [blame]

2657

member = str(member).replace("::", "->")

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2658

paramdecl += ' ' + functionprefix + 'WriteObject(my_data, ' + member + ');\n'

2659

else:

2660

paramtype = param.find('type')

2661

if paramtype is not None:

2662

paramtype = paramtype.text

2663

else:

2664

paramtype = 'None'

2665

if paramtype in thread_check_dispatchable_objects or paramtype in thread_check_nondispatchable_objects:

2666

if self.paramIsArray(param) and ('pPipelines' != paramname.text):

Michael Mc Donnell

c133bd0

2016-03-17 21:18:32 -0700

[diff] [blame]

2667

paramdecl += ' for (uint32_t index=0;index<' + param.attrib.get('len') + ';index++) {\n'

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2668

paramdecl += ' ' + functionprefix + 'ReadObject(my_data, ' + paramname.text + '[index]);\n'

2669

paramdecl += ' }\n'

2670

elif not self.paramIsPointer(param):

2671

# Pointer params are often being created.

2672

# They are not being read from.

2673

paramdecl += ' ' + functionprefix + 'ReadObject(my_data, ' + paramname.text + ');\n'

2674

explicitexternsyncparams = cmd.findall("param[@externsync]")

2675

if (explicitexternsyncparams is not None):

2676

for param in explicitexternsyncparams:

2677

externsyncattrib = param.attrib.get('externsync')

2678

paramname = param.find('name')

Mike Stroyan

2016-07-13 10:10:25 -0600

[diff] [blame]

2679

paramdecl += ' // Host access to '

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2680

if externsyncattrib == 'true':

2681

if self.paramIsArray(param):

2682

paramdecl += 'each member of ' + paramname.text

2683

elif self.paramIsPointer(param):

2684

paramdecl += 'the object referenced by ' + paramname.text

2685

else:

2686

paramdecl += paramname.text

2687

else:

2688

paramdecl += externsyncattrib

2689

paramdecl += ' must be externally synchronized\n'

2690

2691

# Find and add any "implicit" parameters that are thread unsafe

2692

implicitexternsyncparams = cmd.find('implicitexternsyncparams')

2693

if (implicitexternsyncparams is not None):

2694

for elem in implicitexternsyncparams:

2695

paramdecl += ' // '

2696

paramdecl += elem.text

2697

paramdecl += ' must be externally synchronized between host accesses\n'

2698

2699

if (paramdecl == ''):

return None

else:

return paramdecl

def beginFile(self, genOpts):

2704

OutputGenerator.beginFile(self, genOpts)

2705

# C-specific

2706

#

Chia-I Wu

2016-05-16 09:58:50 +0800

[diff] [blame]

2707

# Multiple inclusion protection & C++ namespace.

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2708

if (genOpts.protectFile and self.genOpts.filename):

2709

headerSym = '__' + re.sub('\.h', '_h_', os.path.basename(self.genOpts.filename))

2710

write('#ifndef', headerSym, file=self.outFile)

2711

write('#define', headerSym, '1', file=self.outFile)

2712

self.newline()

Chia-I Wu

2016-05-16 09:58:50 +0800

[diff] [blame]

2713

write('namespace threading {', file=self.outFile)

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2714

self.newline()

2715

#

2716

# User-supplied prefix text, if any (list of strings)

2717

if (genOpts.prefixText):

2718

for s in genOpts.prefixText:

2719

write(s, file=self.outFile)

2720

def endFile(self):

2721

# C-specific

Chia-I Wu

2016-05-16 09:58:50 +0800

[diff] [blame]

2722

# Finish C++ namespace and multiple inclusion protection

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2723

self.newline()

2724

# record intercepted procedures

2725

write('// intercepts', file=self.outFile)

2726

write('struct { const char* name; PFN_vkVoidFunction pFunc;} procmap[] = {', file=self.outFile)

2727

write('\n'.join(self.intercepts), file=self.outFile)

2728

write('};\n', file=self.outFile)

2729

self.newline()

Chia-I Wu

2016-05-16 09:58:50 +0800

[diff] [blame]

2730

write('} // namespace threading', file=self.outFile)

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2731

if (self.genOpts.protectFile and self.genOpts.filename):

2732

self.newline()

2733

write('#endif', file=self.outFile)

2734

# Finish processing in superclass

2735

OutputGenerator.endFile(self)

2736

def beginFeature(self, interface, emit):

2737

#write('// starting beginFeature', file=self.outFile)

2738

# Start processing in superclass

2739

OutputGenerator.beginFeature(self, interface, emit)

2740

# C-specific

2741

# Accumulate includes, defines, types, enums, function pointer typedefs,

2742

# end function prototypes separately for this feature. They're only

2743

# printed in endFeature().

2744

self.sections = dict([(section, []) for section in self.ALL_SECTIONS])

2745

#write('// ending beginFeature', file=self.outFile)

2746

def endFeature(self):

2747

# C-specific

2748

# Actually write the interface to the output file.

2749

#write('// starting endFeature', file=self.outFile)

2750

if (self.emit):

2751

self.newline()

2752

if (self.genOpts.protectFeature):

2753

write('#ifndef', self.featureName, file=self.outFile)

2754

# If type declarations are needed by other features based on

2755

# this one, it may be necessary to suppress the ExtraProtect,

2756

# or move it below the 'for section...' loop.

2757

#write('// endFeature looking at self.featureExtraProtect', file=self.outFile)

2758

if (self.featureExtraProtect != None):

2759

write('#ifdef', self.featureExtraProtect, file=self.outFile)

2760

#write('#define', self.featureName, '1', file=self.outFile)

2761

for section in self.TYPE_SECTIONS:

2762

#write('// endFeature writing section'+section, file=self.outFile)

2763

contents = self.sections[section]

2764

if contents:

2765

write('\n'.join(contents), file=self.outFile)

2766

self.newline()

2767

#write('// endFeature looking at self.sections[command]', file=self.outFile)

2768

if (self.sections['command']):

2769

write('\n'.join(self.sections['command']), end='', file=self.outFile)

2770

self.newline()

2771

if (self.featureExtraProtect != None):

2772

write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)

2773

if (self.genOpts.protectFeature):

2774

write('#endif /*', self.featureName, '*/', file=self.outFile)

2775

# Finish processing in superclass

2776

OutputGenerator.endFeature(self)

2777

#write('// ending endFeature', file=self.outFile)

2778

#

2779

# Append a definition to the specified section

2780

def appendSection(self, section, text):

2781

# self.sections[section].append('SECTION: ' + section + '\n')

2782

self.sections[section].append(text)

2783

#

2784

# Type generation

2785

def genType(self, typeinfo, name):

2786

pass

2787

#

2788

# Struct (e.g. C "struct" type) generation.

2789

# This is a special case of the <type> tag where the contents are

2790

# interpreted as a set of <member> tags instead of freeform C

2791

# C type declarations. The <member> tags are just like <param>

2792

# tags - they are a declaration of a struct or union member.

2793

# Only simple member declarations are supported (no nested

2794

# structs etc.)

2795

def genStruct(self, typeinfo, typeName):

2796

OutputGenerator.genStruct(self, typeinfo, typeName)

2797

body = 'typedef ' + typeinfo.elem.get('category') + ' ' + typeName + ' {\n'

2798

# paramdecl = self.makeCParamDecl(typeinfo.elem, self.genOpts.alignFuncParam)

2799

for member in typeinfo.elem.findall('.//member'):

2800

body += self.makeCParamDecl(member, self.genOpts.alignFuncParam)

2801

body += ';\n'

2802

body += '} ' + typeName + ';\n'

2803

self.appendSection('struct', body)

2804

#

2805

# Group (e.g. C "enum" type) generation.

2806

# These are concatenated together with other types.

2807

def genGroup(self, groupinfo, groupName):

2808

pass

2809

# Enumerant generation

2810

# <enum> tags may specify their values in several ways, but are usually

2811

# just integers.

2812

def genEnum(self, enuminfo, name):

pass

#

# Command generation

def genCmd(self, cmdinfo, name):

Chia-I Wu

2016-05-16 09:58:50 +0800

[diff] [blame]

2817

# Commands shadowed by interface functions and are not implemented

2818

interface_functions = [

2819

'vkEnumerateInstanceLayerProperties',

2820

'vkEnumerateInstanceExtensionProperties',

2821

'vkEnumerateDeviceLayerProperties',

2822

]

2823

if name in interface_functions:

2824

return

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2825

special_functions = [

2826

'vkGetDeviceProcAddr',

2827

'vkGetInstanceProcAddr',

'vkCreateDevice',

'vkDestroyDevice',

'vkCreateInstance',

'vkDestroyInstance',

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2832

'vkAllocateCommandBuffers',

2833

'vkFreeCommandBuffers',

2834

'vkCreateDebugReportCallbackEXT',

2835

'vkDestroyDebugReportCallbackEXT',

2836

]

2837

if name in special_functions:

Chia-I Wu

2016-05-16 09:58:50 +0800

[diff] [blame]

2838

decls = self.makeCDecls(cmdinfo.elem)

2839

self.appendSection('command', '')

2840

self.appendSection('command', '// declare only')

2841

self.appendSection('command', decls[0])

Chia-I Wu

33b4ce8

2016-05-16 10:02:06 +0800

[diff] [blame]

2842

self.intercepts += [ ' {"%s", reinterpret_cast<PFN_vkVoidFunction>(%s)},' % (name,name[2:]) ]

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2843

return

2844

if "KHR" in name:

2845

self.appendSection('command', '// TODO - not wrapping KHR function ' + name)

2846

return

Dustin Graves

2016-05-10 16:44:16 -0600

[diff] [blame]

2847

if ("DebugMarker" in name) and ("EXT" in name):

2848

self.appendSection('command', '// TODO - not wrapping EXT function ' + name)

2849

return

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2850

# Determine first if this function needs to be intercepted

2851

startthreadsafety = self.makeThreadUseBlock(cmdinfo.elem, 'start')

2852

if startthreadsafety is None:

2853

return

2854

finishthreadsafety = self.makeThreadUseBlock(cmdinfo.elem, 'finish')

2855

# record that the function will be intercepted

2856

if (self.featureExtraProtect != None):

2857

self.intercepts += [ '#ifdef %s' % self.featureExtraProtect ]

Chia-I Wu

33b4ce8

2016-05-16 10:02:06 +0800

[diff] [blame]

2858

self.intercepts += [ ' {"%s", reinterpret_cast<PFN_vkVoidFunction>(%s)},' % (name,name[2:]) ]

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2859

if (self.featureExtraProtect != None):

2860

self.intercepts += [ '#endif' ]

2861

2862

OutputGenerator.genCmd(self, cmdinfo, name)

2863

#

2864

decls = self.makeCDecls(cmdinfo.elem)

2865

self.appendSection('command', '')

2866

self.appendSection('command', decls[0][:-1])

2867

self.appendSection('command', '{')

2868

# setup common to call wrappers

2869

# first parameter is always dispatchable

2870

dispatchable_type = cmdinfo.elem.find('param/type').text

2871

dispatchable_name = cmdinfo.elem.find('param/name').text

2872

self.appendSection('command', ' dispatch_key key = get_dispatch_key('+dispatchable_name+');')

2873

self.appendSection('command', ' layer_data *my_data = get_my_data_ptr(key, layer_data_map);')

2874

if dispatchable_type in ["VkPhysicalDevice", "VkInstance"]:

2875

self.appendSection('command', ' VkLayerInstanceDispatchTable *pTable = my_data->instance_dispatch_table;')

2876

else:

2877

self.appendSection('command', ' VkLayerDispatchTable *pTable = my_data->device_dispatch_table;')

2878

# Declare result variable, if any.

2879

resulttype = cmdinfo.elem.find('proto/type')

2880

if (resulttype != None and resulttype.text == 'void'):

2881

resulttype = None

2882

if (resulttype != None):

2883

self.appendSection('command', ' ' + resulttype.text + ' result;')

2884

assignresult = 'result = '

else:

assignresult = ''

Mike Stroyan

2016-07-13 10:10:25 -0600

[diff] [blame]

2888

self.appendSection('command', ' bool threadChecks = startMultiThread();')

2889

self.appendSection('command', ' if (threadChecks) {')

2890

self.appendSection('command', " "+"\n ".join(str(startthreadsafety).rstrip().split("\n")))

2891

self.appendSection('command', ' }')

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2892

params = cmdinfo.elem.findall('param/name')

2893

paramstext = ','.join([str(param.text) for param in params])

2894

API = cmdinfo.elem.attrib.get('name').replace('vk','pTable->',1)

2895

self.appendSection('command', ' ' + assignresult + API + '(' + paramstext + ');')

Mike Stroyan

2016-07-13 10:10:25 -0600

[diff] [blame]

2896

self.appendSection('command', ' if (threadChecks) {')

2897

self.appendSection('command', " "+"\n ".join(str(finishthreadsafety).rstrip().split("\n")))

2898

self.appendSection('command', ' } else {')

2899

self.appendSection('command', ' finishMultiThread();')

2900

self.appendSection('command', ' }')

Mike Stroyan

2015-11-02 15:30:20 -0700

[diff] [blame]

2901

# Return result variable, if any.

2902

if (resulttype != None):

2903

self.appendSection('command', ' return result;')

2904

self.appendSection('command', '}')

Chia-I Wu

33b4ce8

2016-05-16 10:02:06 +0800

[diff] [blame]

2905

#

2906

# override makeProtoName to drop the "vk" prefix

2907

def makeProtoName(self, name, tail):

2908

return self.genOpts.apientry + name[2:] + tail

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2909

2910

# ParamCheckerOutputGenerator - subclass of OutputGenerator.

2911

# Generates param checker layer code.

2912

#

2913

# ---- methods ----

2914

# ParamCheckerOutputGenerator(errFile, warnFile, diagFile) - args as for

2915

# OutputGenerator. Defines additional internal state.

2916

# ---- methods overriding base class ----

2917

# beginFile(genOpts)

2918

# endFile()

2919

# beginFeature(interface, emit)

2920

# endFeature()

2921

# genType(typeinfo,name)

2922

# genStruct(typeinfo,name)

2923

# genGroup(groupinfo,name)

2924

# genEnum(enuminfo, name)

2925

# genCmd(cmdinfo)

2926

class ParamCheckerOutputGenerator(OutputGenerator):

2927

"""Generate ParamChecker code based on XML element attributes"""

2928

# This is an ordered list of sections in the header file.

2929

ALL_SECTIONS = ['command']

2930

def __init__(self,

2931

errFile = sys.stderr,

2932

warnFile = sys.stderr,

2933

diagFile = sys.stdout):

2934

OutputGenerator.__init__(self, errFile, warnFile, diagFile)

2935

self.INDENT_SPACES = 4

2936

# Commands to ignore

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

2937

self.blacklist = [

Dustin Graves

2016-03-03 14:17:08 -0700

[diff] [blame]

2938

'vkGetInstanceProcAddr',

2939

'vkGetDeviceProcAddr',

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

2940

'vkEnumerateInstanceLayerProperties',

2941

'vkEnumerateInstanceExtensionsProperties',

2942

'vkEnumerateDeviceLayerProperties',

2943

'vkEnumerateDeviceExtensionsProperties',

2944

'vkCreateDebugReportCallbackEXT',

2945

'vkDebugReportMessageEXT']

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

2946

# Validation conditions for some special case struct members that are conditionally validated

2947

self.structMemberValidationConditions = { 'VkPipelineColorBlendStateCreateInfo' : { 'logicOp' : '{}logicOpEnable == VK_TRUE' } }

Dustin Graves

2016-07-19 13:17:35 -0600

[diff] [blame]

2948

# Header version

2949

self.headerVersion = None

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2950

# Internal state - accumulators for different inner block text

2951

self.sections = dict([(section, []) for section in self.ALL_SECTIONS])

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

2952

self.structNames = [] # List of Vulkan struct typenames

2953

self.stypes = [] # Values from the VkStructureType enumeration

2954

self.structTypes = dict() # Map of Vulkan struct typename to required VkStructureType

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

2955

self.handleTypes = set() # Set of handle type names

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

2956

self.commands = [] # List of CommandData records for all Vulkan commands

2957

self.structMembers = [] # List of StructMemberData records for all Vulkan structs

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

2958

self.validatedStructs = dict() # Map of structs type names to generated validation code for that struct type

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

2959

self.enumRanges = dict() # Map of enum name to BEGIN/END range values

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

2960

self.flags = set() # Map of flags typenames

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

2961

self.flagBits = dict() # Map of flag bits typename to list of values

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2962

# Named tuples to store struct and command data

2963

self.StructType = namedtuple('StructType', ['name', 'value'])

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

2964

self.CommandParam = namedtuple('CommandParam', ['type', 'name', 'ispointer', 'isstaticarray', 'isbool', 'israngedenum',

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

2965

'isconst', 'isoptional', 'iscount', 'noautovalidity', 'len', 'extstructs',

2966

'condition', 'cdecl'])

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2967

self.CommandData = namedtuple('CommandData', ['name', 'params', 'cdecl'])

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

2968

self.StructMemberData = namedtuple('StructMemberData', ['name', 'members'])

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2969

#

2970

def incIndent(self, indent):

2971

inc = ' ' * self.INDENT_SPACES

2972

if indent:

2973

return indent + inc

2974

return inc

Dustin Graves

2016-03-03 14:17:08 -0700

[diff] [blame]

2975

#

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

2976

def decIndent(self, indent):

2977

if indent and (len(indent) > self.INDENT_SPACES):

2978

return indent[:-self.INDENT_SPACES]

2979

return ''

2980

#

2981

def beginFile(self, genOpts):

2982

OutputGenerator.beginFile(self, genOpts)

2983

# C-specific

2984

#

2985

# User-supplied prefix text, if any (list of strings)

2986

if (genOpts.prefixText):

2987

for s in genOpts.prefixText:

2988

write(s, file=self.outFile)

2989

#

2990

# Multiple inclusion protection & C++ wrappers.

2991

if (genOpts.protectFile and self.genOpts.filename):

2992

headerSym = re.sub('\.h', '_H', os.path.basename(self.genOpts.filename)).upper()

2993

write('#ifndef', headerSym, file=self.outFile)

2994

write('#define', headerSym, '1', file=self.outFile)

2995

self.newline()

2996

#

2997

# Headers

Dustin Graves

b210cee

2016-03-31 09:50:42 -0600

[diff] [blame]

2998

write('#include <string>', file=self.outFile)

2999

self.newline()

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3000

write('#include "vulkan/vulkan.h"', file=self.outFile)

Dustin Graves

58c2f66

2016-03-08 17:48:20 -0700

[diff] [blame]

3001

write('#include "vk_layer_extension_utils.h"', file=self.outFile)

Mark Lobodzinski

739391a

2016-03-17 15:08:18 -0600

[diff] [blame]

3002

write('#include "parameter_validation_utils.h"', file=self.outFile)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

#

# Macros

self.newline()

write('#ifndef UNUSED_PARAMETER', file=self.outFile)

3007

write('#define UNUSED_PARAMETER(x) (void)(x)', file=self.outFile)

3008

write('#endif // UNUSED_PARAMETER', file=self.outFile)

Dustin Graves

b83fc2d

2016-05-04 12:56:08 -0600

[diff] [blame]

#

# Namespace

self.newline()

write('namespace parameter_validation {', file = self.outFile)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3013

def endFile(self):

3014

# C-specific

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3015

self.newline()

Dustin Graves

b83fc2d

2016-05-04 12:56:08 -0600

[diff] [blame]

3016

# Namespace

3017

write('} // namespace parameter_validation', file = self.outFile)

3018

# Finish C++ wrapper and multiple inclusion protection

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3019

if (self.genOpts.protectFile and self.genOpts.filename):

3020

self.newline()

3021

write('#endif', file=self.outFile)

3022

# Finish processing in superclass

3023

OutputGenerator.endFile(self)

3024

def beginFeature(self, interface, emit):

3025

# Start processing in superclass

3026

OutputGenerator.beginFeature(self, interface, emit)

3027

# C-specific

3028

# Accumulate includes, defines, types, enums, function pointer typedefs,

3029

# end function prototypes separately for this feature. They're only

3030

# printed in endFeature().

Dustin Graves

2016-07-19 13:17:35 -0600

[diff] [blame]

3031

self.headerVersion = None

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3032

self.sections = dict([(section, []) for section in self.ALL_SECTIONS])

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3033

self.structNames = []

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3034

self.stypes = []

3035

self.structTypes = dict()

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3036

self.handleTypes = set()

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3037

self.commands = []

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3038

self.structMembers = []

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3039

self.validatedStructs = dict()

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3040

self.enumRanges = dict()

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3041

self.flags = set()

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3042

self.flagBits = dict()

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3043

def endFeature(self):

3044

# C-specific

3045

# Actually write the interface to the output file.

3046

if (self.emit):

3047

self.newline()

3048

# If type declarations are needed by other features based on

3049

# this one, it may be necessary to suppress the ExtraProtect,

3050

# or move it below the 'for section...' loop.

3051

if (self.featureExtraProtect != None):

3052

write('#ifdef', self.featureExtraProtect, file=self.outFile)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3053

# Generate the struct member checking code from the captured data

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3054

self.processStructMemberData()

3055

# Generate the command parameter checking code from the captured data

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3056

self.processCmdData()

Dustin Graves

2016-07-19 13:17:35 -0600

[diff] [blame]

3057

# Write the declaration for the HeaderVersion

3058

if self.headerVersion:

3059

write('const uint32_t GeneratedHeaderVersion = {};'.format(self.headerVersion), file=self.outFile)

3060

self.newline()

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3061

# Write the declarations for the VkFlags values combining all flag bits

3062

for flag in sorted(self.flags):

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3063

flagBits = flag.replace('Flags', 'FlagBits')

3064

if flagBits in self.flagBits:

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3065

bits = self.flagBits[flagBits]

3066

decl = 'const {} All{} = {}'.format(flag, flagBits, bits[0])

for bit in bits[1:]:

decl += '|' + bit

decl += ';'

write(decl, file=self.outFile)

3071

self.newline()

3072

# Write the parameter validation code to the file

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3073

if (self.sections['command']):

3074

if (self.genOpts.protectProto):

3075

write(self.genOpts.protectProto,

3076

self.genOpts.protectProtoStr, file=self.outFile)

3077

write('\n'.join(self.sections['command']), end='', file=self.outFile)

3078

if (self.featureExtraProtect != None):

3079

write('#endif /*', self.featureExtraProtect, '*/', file=self.outFile)

3080

else:

3081

self.newline()

3082

# Finish processing in superclass

3083

OutputGenerator.endFeature(self)

3084

#

3085

# Append a definition to the specified section

3086

def appendSection(self, section, text):

3087

# self.sections[section].append('SECTION: ' + section + '\n')

3088

self.sections[section].append(text)

3089

#

3090

# Type generation

3091

def genType(self, typeinfo, name):

3092

OutputGenerator.genType(self, typeinfo, name)

3093

typeElem = typeinfo.elem

3094

# If the type is a struct type, traverse the imbedded <member> tags

3095

# generating a structure. Otherwise, emit the tag text.

3096

category = typeElem.get('category')

3097

if (category == 'struct' or category == 'union'):

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3098

self.structNames.append(name)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3099

self.genStruct(typeinfo, name)

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3100

elif (category == 'handle'):

3101

self.handleTypes.add(name)

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3102

elif (category == 'bitmask'):

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3103

self.flags.add(name)

Dustin Graves

2016-07-19 13:17:35 -0600

[diff] [blame]

3104

elif (category == 'define'):

3105

if name == 'VK_HEADER_VERSION':

3106

nameElem = typeElem.find('name')

3107

self.headerVersion = noneStr(nameElem.tail).strip()

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3108

#

3109

# Struct parameter check generation.

3110

# This is a special case of the <type> tag where the contents are

3111

# interpreted as a set of <member> tags instead of freeform C

3112

# C type declarations. The <member> tags are just like <param>

3113

# tags - they are a declaration of a struct or union member.

3114

# Only simple member declarations are supported (no nested

3115

# structs etc.)

3116

def genStruct(self, typeinfo, typeName):

3117

OutputGenerator.genStruct(self, typeinfo, typeName)

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

3118

conditions = self.structMemberValidationConditions[typeName] if typeName in self.structMemberValidationConditions else None

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3119

members = typeinfo.elem.findall('.//member')

3120

#

3121

# Iterate over members once to get length parameters for arrays

3122

lens = set()

3123

for member in members:

3124

len = self.getLen(member)

if len:

lens.add(len)

#

# Generate member info

3129

membersInfo = []

3130

for member in members:

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3131

# Get the member's type and name

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3132

info = self.getTypeNameTuple(member)

3133

type = info[0]

3134

name = info[1]

3135

stypeValue = ''

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3136

cdecl = self.makeCParamDecl(member, 0)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3137

# Process VkStructureType

3138

if type == 'VkStructureType':

3139

# Extract the required struct type value from the comments

3140

# embedded in the original text defining the 'typeinfo' element

3141

rawXml = etree.tostring(typeinfo.elem).decode('ascii')

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3142

result = re.search(r'VK_STRUCTURE_TYPE_\w+', rawXml)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3143

if result:

3144

value = result.group(0)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3145

else:

Dustin Graves

2016-05-10 16:44:16 -0600

[diff] [blame]

3146

value = self.genVkStructureType(typeName)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3147

# Store the required type value

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3148

self.structTypes[typeName] = self.StructType(name=name, value=value)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3149

#

3150

# Store pointer/array/string info

3151

# Check for parameter name in lens set

iscount = False

if name in lens:

iscount = True

# The pNext members are not tagged as optional, but are treated as

3156

# optional for parameter NULL checks. Static array members

3157

# are also treated as optional to skip NULL pointer validation, as

3158

# they won't be NULL.

3159

isstaticarray = self.paramIsStaticArray(member)

3160

isoptional = False

3161

if self.paramIsOptional(member) or (name == 'pNext') or (isstaticarray):

3162

isoptional = True

3163

membersInfo.append(self.CommandParam(type=type, name=name,

3164

ispointer=self.paramIsPointer(member),

3165

isstaticarray=isstaticarray,

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3166

isbool=True if type == 'VkBool32' else False,

3167

israngedenum=True if type in self.enumRanges else False,

3168

isconst=True if 'const' in cdecl else False,

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3169

isoptional=isoptional,

3170

iscount=iscount,

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3171

noautovalidity=True if member.attrib.get('noautovalidity') is not None else False,

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3172

len=self.getLen(member),

Dustin Graves

58c2f66

2016-03-08 17:48:20 -0700

[diff] [blame]

3173

extstructs=member.attrib.get('validextensionstructs') if name == 'pNext' else None,

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

3174

condition=conditions[name] if conditions and name in conditions else None,

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3175

cdecl=cdecl))

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3176

self.structMembers.append(self.StructMemberData(name=typeName, members=membersInfo))

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3177

#

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3178

# Capture group (e.g. C "enum" type) info to be used for

3179

# param check code generation.

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3180

# These are concatenated together with other types.

3181

def genGroup(self, groupinfo, groupName):

3182

OutputGenerator.genGroup(self, groupinfo, groupName)

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3183

groupElem = groupinfo.elem

3184

#

3185

# Store the sType values

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3186

if groupName == 'VkStructureType':

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3187

for elem in groupElem.findall('enum'):

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3188

self.stypes.append(elem.get('name'))

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3189

elif 'FlagBits' in groupName:

3190

bits = []

3191

for elem in groupElem.findall('enum'):

3192

bits.append(elem.get('name'))

3193

if bits:

3194

self.flagBits[groupName] = bits

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3195

else:

3196

# Determine if begin/end ranges are needed (we don't do this for VkStructureType, which has a more finely grained check)

3197

expandName = re.sub(r'([0-9a-z_])([A-Z0-9][^A-Z0-9]?)',r'\1_\2',groupName).upper()

3198

expandPrefix = expandName

3199

expandSuffix = ''

3200

expandSuffixMatch = re.search(r'[A-Z][A-Z]+$',groupName)

3201

if expandSuffixMatch:

3202

expandSuffix = '_' + expandSuffixMatch.group()

3203

# Strip off the suffix from the prefix

3204

expandPrefix = expandName.rsplit(expandSuffix, 1)[0]

3205

isEnum = ('FLAG_BITS' not in expandPrefix)

3206

if isEnum:

3207

self.enumRanges[groupName] = (expandPrefix + '_BEGIN_RANGE' + expandSuffix, expandPrefix + '_END_RANGE' + expandSuffix)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3208

#

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3209

# Capture command parameter info to be used for param

3210

# check code generation.

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3211

def genCmd(self, cmdinfo, name):

3212

OutputGenerator.genCmd(self, cmdinfo, name)

3213

if name not in self.blacklist:

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3214

params = cmdinfo.elem.findall('param')

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3215

# Get list of array lengths

3216

lens = set()

3217

for param in params:

3218

len = self.getLen(param)

if len:

lens.add(len)

# Get param info

paramsInfo = []

for param in params:

paramInfo = self.getTypeNameTuple(param)

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3225

cdecl = self.makeCParamDecl(param, 0)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3226

# Check for parameter name in lens set

3227

iscount = False

3228

if paramInfo[1] in lens:

3229

iscount = True

3230

paramsInfo.append(self.CommandParam(type=paramInfo[0], name=paramInfo[1],

3231

ispointer=self.paramIsPointer(param),

3232

isstaticarray=self.paramIsStaticArray(param),

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3233

isbool=True if paramInfo[0] == 'VkBool32' else False,

3234

israngedenum=True if paramInfo[0] in self.enumRanges else False,

3235

isconst=True if 'const' in cdecl else False,

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3236

isoptional=self.paramIsOptional(param),

3237

iscount=iscount,

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3238

noautovalidity=True if param.attrib.get('noautovalidity') is not None else False,

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3239

len=self.getLen(param),

Dustin Graves

58c2f66

2016-03-08 17:48:20 -0700

[diff] [blame]

3240

extstructs=None,

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

3241

condition=None,

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3242

cdecl=cdecl))

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3243

self.commands.append(self.CommandData(name=name, params=paramsInfo, cdecl=self.makeCDecls(cmdinfo.elem)[0]))

3244

#

3245

# Check if the parameter passed in is a pointer

3246

def paramIsPointer(self, param):

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3247

ispointer = 0

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3248

paramtype = param.find('type')

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3249

if (paramtype.tail is not None) and ('*' in paramtype.tail):

3250

ispointer = paramtype.tail.count('*')

Dustin Graves

27a912a

2016-03-07 17:52:14 -0700

[diff] [blame]

3251

elif paramtype.text[:4] == 'PFN_':

3252

# Treat function pointer typedefs as a pointer to a single value

3253

ispointer = 1

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3254

return ispointer

3255

#

3256

# Check if the parameter passed in is a static array

3257

def paramIsStaticArray(self, param):

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3258

isstaticarray = 0

3259

paramname = param.find('name')

3260

if (paramname.tail is not None) and ('[' in paramname.tail):

3261

isstaticarray = paramname.tail.count('[')

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3262

return isstaticarray

3263

#

3264

# Check if the parameter passed in is optional

3265

# Returns a list of Boolean values for comma separated len attributes (len='false,true')

3266

def paramIsOptional(self, param):

3267

# See if the handle is optional

3268

isoptional = False

3269

# Simple, if it's optional, return true

3270

optString = param.attrib.get('optional')

3271

if optString:

3272

if optString == 'true':

3273

isoptional = True

3274

elif ',' in optString:

3275

opts = []

3276

for opt in optString.split(','):

val = opt.strip()

if val == 'true':

opts.append(True)

elif val == 'false':

opts.append(False)

else:

print('Unrecognized len attribute value',val)

3284

isoptional = opts

3285

return isoptional

3286

#

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3287

# Check if the handle passed in is optional

3288

# Uses the same logic as ValidityOutputGenerator.isHandleOptional

3289

def isHandleOptional(self, param, lenParam):

3290

# Simple, if it's optional, return true

3291

if param.isoptional:

3292

return True

3293

# If no validity is being generated, it usually means that validity is complex and not absolute, so let's say yes.

3294

if param.noautovalidity:

3295

return True

3296

# If the parameter is an array and we haven't already returned, find out if any of the len parameters are optional

3297

if lenParam and lenParam.isoptional:

3298

return True

3299

return False

3300

#

Dustin Graves

2016-05-10 16:44:16 -0600

[diff] [blame]

3301

# Generate a VkStructureType based on a structure typename

3302

def genVkStructureType(self, typename):

3303

# Add underscore between lowercase then uppercase

3304

value = re.sub('([a-z0-9])([A-Z])', r'\1_\2', typename)

3305

# Change to uppercase

3306

value = value.upper()

3307

# Add STRUCTURE_TYPE_

3308

return re.sub('VK_', 'VK_STRUCTURE_TYPE_', value)

3309

#

3310

# Get the cached VkStructureType value for the specified struct typename, or generate a VkStructureType

3311

# value assuming the struct is defined by a different feature

3312

def getStructType(self, typename):

3313

value = None

3314

if typename in self.structTypes:

3315

value = self.structTypes[typename].value

3316

else:

3317

value = self.genVkStructureType(typename)

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3318

self.logMsg('diag', 'ParameterValidation: Generating {} for {} structure type that was not defined by the current feature'.format(value, typename))

Dustin Graves

2016-05-10 16:44:16 -0600

[diff] [blame]

3319

return value

3320

#

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3321

# Retrieve the value of the len tag

3322

def getLen(self, param):

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3323

result = None

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3324

len = param.attrib.get('len')

3325

if len and len != 'null-terminated':

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3326

# For string arrays, 'len' can look like 'count,null-terminated',

3327

# indicating that we have a null terminated array of strings. We

3328

# strip the null-terminated from the 'len' field and only return

3329

# the parameter specifying the string count

3330

if 'null-terminated' in len:

3331

result = len.split(',')[0]

3332

else:

3333

result = len

Mark Lobodzinski

3b34af0

2016-09-27 13:08:15 -0600

[diff] [blame]

3334

result = str(result).replace('::', '->')

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3335

return result

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3336

#

3337

# Retrieve the type and name for a parameter

3338

def getTypeNameTuple(self, param):

type = ''

name = ''

for elem in param:

if elem.tag == 'type':

3343

type = noneStr(elem.text)

3344

elif elem.tag == 'name':

3345

name = noneStr(elem.text)

3346

return (type, name)

3347

#

3348

# Find a named parameter in a parameter list

3349

def getParamByName(self, params, name):

3350

for param in params:

3351

if param.name == name:

3352

return param

3353

return None

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3354

#

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

3355

# Extract length values from latexmath. Currently an inflexible solution that looks for specific

3356

# patterns that are found in vk.xml. Will need to be updated when new patterns are introduced.

3357

def parseLateXMath(self, source):

3358

name = 'ERROR'

3359

decoratedName = 'ERROR'

3360

if 'mathit' in source:

3361

# Matches expressions similar to 'latexmath:[$\lceil{\mathit{rasterizationSamples} \over 32}\rceil$]'

3362

match = re.match(r'latexmath\s*\:\s*\[\s*\$\\l(\w+)\s*\{\s*\\mathit\s*\{\s*(\w+)\s*\}\s*\\over\s*(\d+)\s*\}\s*\\r(\w+)\$\s*\]', source)

3363

if not match or match.group(1) != match.group(4):

3364

raise 'Unrecognized latexmath expression'

3365

name = match.group(2)

3366

decoratedName = '{}({}/{})'.format(*match.group(1, 2, 3))

3367

else:

3368

# Matches expressions similar to 'latexmath : [$dataSize \over 4$]'

3369

match = re.match(r'latexmath\s*\:\s*\[\s*\$\s*(\w+)\s*\\over\s*(\d+)\s*\$\s*\]', source)

3370

name = match.group(1)

3371

decoratedName = '{}/{}'.format(*match.group(1, 2))

3372

return name, decoratedName

3373

#

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3374

# Get the length paramater record for the specified parameter name

3375

def getLenParam(self, params, name):

lenParam = None

if name:

if '->' in name:

# The count is obtained by dereferencing a member of a struct parameter

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3380

lenParam = self.CommandParam(name=name, iscount=True, ispointer=False, isbool=False, israngedenum=False, isconst=False,

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3381

isstaticarray=None, isoptional=False, type=None, noautovalidity=False, len=None, extstructs=None,

3382

condition=None, cdecl=None)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3383

elif 'latexmath' in name:

Dustin Graves

2016-03-28 16:17:38 -0600

[diff] [blame]

3384

lenName, decoratedName = self.parseLateXMath(name)

3385

lenParam = self.getParamByName(params, lenName)

3386

# TODO: Zero-check the result produced by the equation?

3387

# Copy the stored len parameter entry and overwrite the name with the processed latexmath equation

3388

#param = self.getParamByName(params, lenName)

3389

#lenParam = self.CommandParam(name=decoratedName, iscount=param.iscount, ispointer=param.ispointer,

3390

# isoptional=param.isoptional, type=param.type, len=param.len,

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

3391

# isstaticarray=param.isstaticarray, extstructs=param.extstructs,

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3392

# noautovalidity=True, condition=None, cdecl=param.cdecl)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3393

else:

3394

lenParam = self.getParamByName(params, name)

3395

return lenParam

3396

#

Mark Lobodzinski

739391a

2016-03-17 15:08:18 -0600

[diff] [blame]

3397

# Convert a vulkan.h command declaration into a parameter_validation.h definition

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3398

def getCmdDef(self, cmd):

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3399

#

3400

# Strip the trailing ';' and split into individual lines

3401

lines = cmd.cdecl[:-1].split('\n')

3402

# Replace Vulkan prototype

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3403

lines[0] = 'static bool parameter_validation_' + cmd.name + '('

Dustin Graves

2016-03-03 14:17:08 -0700

[diff] [blame]

3404

# Replace the first argument with debug_report_data, when the first

3405

# argument is a handle (not vkCreateInstance)

3406

reportData = ' debug_report_data*'.ljust(self.genOpts.alignFuncParam) + 'report_data,'

3407

if cmd.name != 'vkCreateInstance':

3408

lines[1] = reportData

3409

else:

3410

lines.insert(1, reportData)

Dustin Graves

2016-02-11 10:10:14 -0700

[diff] [blame]

3411

return '\n'.join(lines)

3412

#

Dustin Graves

2016-02-29 13:35:07 -0700

[diff] [blame]

3413

# Generate the code to check for a NULL dereference before calling the

3414

# validation function

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3415

def genCheckedLengthCall(self, name, exprs):

Dustin Graves

2016-02-29 13:35:07 -0700

[diff] [blame]

3416

count = name.count('->')

3417

if count:

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3418

checkedExpr = []

3419

localIndent = ''

Dustin Graves

2016-02-29 13:35:07 -0700

[diff] [blame]

3420

elements = name.split('->')

3421

# Open the if expression blocks

3422

for i in range(0, count):

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3423

checkedExpr.append(localIndent + 'if ({} != NULL) {{\n'.format('->'.join(elements[0:i+1])))

Dustin Graves

2016-02-29 13:35:07 -0700

[diff] [blame]

3424

localIndent = self.incIndent(localIndent)

3425

# Add the validation expression

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3426

for expr in exprs:

3427

checkedExpr.append(localIndent + expr)

Dustin Graves

2016-02-29 13:35:07 -0700

[diff] [blame]

3428

# Close the if blocks

3429

for i in range(0, count):

3430

localIndent = self.decIndent(localIndent)

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3431

checkedExpr.append(localIndent + '}\n')

3432

return [checkedExpr]

Dustin Graves

2016-02-29 13:35:07 -0700

[diff] [blame]

3433

# No if statements were required

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3434

return exprs

3435

#

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

3436

# Generate code to check for a specific condition before executing validation code

3437

def genConditionalCall(self, prefix, condition, exprs):

3438

checkedExpr = []

3439

localIndent = ''

3440

formattedCondition = condition.format(prefix)

3441

checkedExpr.append(localIndent + 'if ({})\n'.format(formattedCondition))

3442

checkedExpr.append(localIndent + '{\n')

3443

localIndent = self.incIndent(localIndent)

3444

for expr in exprs:

3445

checkedExpr.append(localIndent + expr)

3446

localIndent = self.decIndent(localIndent)

3447

checkedExpr.append(localIndent + '}\n')

3448

return [checkedExpr]

3449

#

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3450

# Generate the sType check string

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3451

def makeStructTypeCheck(self, prefix, value, lenValue, valueRequired, lenValueRequired, lenPtrRequired, funcPrintName, lenPrintName, valuePrintName, postProcSpec):

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3452

checkExpr = []

3453

stype = self.structTypes[value.type]

3454

if lenValue:

3455

# This is an array with a pointer to a count value

3456

if lenValue.ispointer:

3457

# When the length parameter is a pointer, there is an extra Boolean parameter in the function call to indicate if it is required

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3458

checkExpr.append('skipCall |= validate_struct_type_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, "{sv}", {pf}{ln}, {pf}{vn}, {sv}, {}, {}, {});\n'.format(

3459

funcPrintName, lenPtrRequired, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, sv=stype.value, pf=prefix, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3460

# This is an array with an integer count value

3461

else:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3462

checkExpr.append('skipCall |= validate_struct_type_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, "{sv}", {pf}{ln}, {pf}{vn}, {sv}, {}, {});\n'.format(

3463

funcPrintName, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, sv=stype.value, pf=prefix, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3464

# This is an individual struct

3465

else:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3466

checkExpr.append('skipCall |= validate_struct_type(report_data, "{}", {ppp}"{}"{pps}, "{sv}", {}{vn}, {sv}, {});\n'.format(

3467

funcPrintName, valuePrintName, prefix, valueRequired, vn=value.name, sv=stype.value, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3468

return checkExpr

3469

#

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3470

# Generate the handle check string

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3471

def makeHandleCheck(self, prefix, value, lenValue, valueRequired, lenValueRequired, funcPrintName, lenPrintName, valuePrintName, postProcSpec):

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3472

checkExpr = []

3473

if lenValue:

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3474

if lenValue.ispointer:

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3475

# This is assumed to be an output array with a pointer to a count value

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3476

raise('Unsupported parameter validation case: Output handle array elements are not NULL checked')

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3477

else:

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3478

# This is an array with an integer count value

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3479

checkExpr.append('skipCall |= validate_handle_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {});\n'.format(

3480

funcPrintName, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, pf=prefix, **postProcSpec))

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3481

else:

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3482

# This is assumed to be an output handle pointer

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3483

raise('Unsupported parameter validation case: Output handles are not NULL checked')

3484

return checkExpr

3485

#

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3486

# Generate check string for an array of VkFlags values

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3487

def makeFlagsArrayCheck(self, prefix, value, lenValue, valueRequired, lenValueRequired, funcPrintName, lenPrintName, valuePrintName, postProcSpec):

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3488

checkExpr = []

3489

flagBitsName = value.type.replace('Flags', 'FlagBits')

3490

if not flagBitsName in self.flagBits:

3491

raise('Unsupported parameter validation case: array of reserved VkFlags')

3492

else:

3493

allFlags = 'All' + flagBitsName

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3494

checkExpr.append('skipCall |= validate_flags_array(report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, "{}", {}, {pf}{}, {pf}{}, {}, {});\n'.format(funcPrintName, lenPrintName, valuePrintName, flagBitsName, allFlags, lenValue.name, value.name, lenValueRequired, valueRequired, pf=prefix, **postProcSpec))

Dustin Graves

2016-04-26 15:37:10 -0600

[diff] [blame]

3495

return checkExpr

3496

#

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3497

# Generate pNext check string

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3498

def makeStructNextCheck(self, prefix, value, funcPrintName, valuePrintName, postProcSpec):

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3499

checkExpr = []

3500

# Generate an array of acceptable VkStructureType values for pNext

3501

extStructCount = 0

3502

extStructVar = 'NULL'

3503

extStructNames = 'NULL'

3504

if value.extstructs:

3505

structs = value.extstructs.split(',')

Dustin Graves

2016-05-10 16:44:16 -0600

[diff] [blame]

3506

checkExpr.append('const VkStructureType allowedStructs[] = {' + ', '.join([self.getStructType(s) for s in structs]) + '};\n')

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3507

extStructCount = 'ARRAY_SIZE(allowedStructs)'

3508

extStructVar = 'allowedStructs'

3509

extStructNames = '"' + ', '.join(structs) + '"'

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3510

checkExpr.append('skipCall |= validate_struct_pnext(report_data, "{}", {ppp}"{}"{pps}, {}, {}{}, {}, {}, GeneratedHeaderVersion);\n'.format(

3511

funcPrintName, valuePrintName, extStructNames, prefix, value.name, extStructCount, extStructVar, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3512

return checkExpr

3513

#

3514

# Generate the pointer check string

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3515

def makePointerCheck(self, prefix, value, lenValue, valueRequired, lenValueRequired, lenPtrRequired, funcPrintName, lenPrintName, valuePrintName, postProcSpec):

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3516

checkExpr = []

3517

if lenValue:

3518

# This is an array with a pointer to a count value

3519

if lenValue.ispointer:

3520

# If count and array parameters are optional, there will be no validation

3521

if valueRequired == 'true' or lenPtrRequired == 'true' or lenValueRequired == 'true':

3522

# When the length parameter is a pointer, there is an extra Boolean parameter in the function call to indicate if it is required

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3523

checkExpr.append('skipCall |= validate_array(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {}, {});\n'.format(

3524

funcPrintName, lenPtrRequired, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, pf=prefix, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3525

# This is an array with an integer count value

3526

else:

3527

# If count and array parameters are optional, there will be no validation

3528

if valueRequired == 'true' or lenValueRequired == 'true':

3529

# Arrays of strings receive special processing

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3530

validationFuncName = 'validate_array' if value.type != 'char' else 'validate_string_array'

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3531

checkExpr.append('skipCall |= {}(report_data, "{}", {ppp}"{ldn}"{pps}, {ppp}"{dn}"{pps}, {pf}{ln}, {pf}{vn}, {}, {});\n'.format(

3532

validationFuncName, funcPrintName, lenValueRequired, valueRequired, ln=lenValue.name, ldn=lenPrintName, dn=valuePrintName, vn=value.name, pf=prefix, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3533

if checkExpr:

3534

if lenValue and ('->' in lenValue.name):

3535

# Add checks to ensure the validation call does not dereference a NULL pointer to obtain the count

3536

checkExpr = self.genCheckedLengthCall(lenValue.name, checkExpr)

3537

# This is an individual struct that is not allowed to be NULL

3538

elif not value.isoptional:

3539

# Function pointers need a reinterpret_cast to void*

3540

if value.type[:4] == 'PFN_':

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3541

checkExpr.append('skipCall |= validate_required_pointer(report_data, "{}", {ppp}"{}"{pps}, reinterpret_cast<const void*>({}{}));\n'.format(funcPrintName, valuePrintName, prefix, value.name, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3542

else:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3543

checkExpr.append('skipCall |= validate_required_pointer(report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcPrintName, valuePrintName, prefix, value.name, **postProcSpec))

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3544

return checkExpr

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3545

#

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3546

# Process struct member validation code, performing name suibstitution if required

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3547

def processStructMemberCode(self, line, funcName, memberNamePrefix, memberDisplayNamePrefix, postProcSpec):

3548

# Build format specifier list

3549

kwargs = {}

3550

if '{postProcPrefix}' in line:

3551

# If we have a tuple that includes a format string and format parameters, need to use ParameterName class

3552

if type(memberDisplayNamePrefix) is tuple:

3553

kwargs['postProcPrefix'] = 'ParameterName('

3554

else:

3555

kwargs['postProcPrefix'] = postProcSpec['ppp']

3556

if '{postProcSuffix}' in line:

3557

# If we have a tuple that includes a format string and format parameters, need to use ParameterName class

3558

if type(memberDisplayNamePrefix) is tuple:

3559

kwargs['postProcSuffix'] = ', ParameterName::IndexVector{{ {}{} }})'.format(postProcSpec['ppi'], memberDisplayNamePrefix[1])

3560

else:

3561

kwargs['postProcSuffix'] = postProcSpec['pps']

3562

if '{postProcInsert}' in line:

3563

# If we have a tuple that includes a format string and format parameters, need to use ParameterName class

3564

if type(memberDisplayNamePrefix) is tuple:

3565

kwargs['postProcInsert'] = '{}{}, '.format(postProcSpec['ppi'], memberDisplayNamePrefix[1])

3566

else:

3567

kwargs['postProcInsert'] = postProcSpec['ppi']

3568

if '{funcName}' in line:

3569

kwargs['funcName'] = funcName

3570

if '{valuePrefix}' in line:

3571

kwargs['valuePrefix'] = memberNamePrefix

3572

if '{displayNamePrefix}' in line:

3573

# Check for a tuple that includes a format string and format parameters to be used with the ParameterName class

3574

if type(memberDisplayNamePrefix) is tuple:

3575

kwargs['displayNamePrefix'] = memberDisplayNamePrefix[0]

3576

else:

3577

kwargs['displayNamePrefix'] = memberDisplayNamePrefix

3578

3579

if kwargs:

3580

# Need to escape the C++ curly braces

3581

if 'IndexVector' in line:

3582

line = line.replace('IndexVector{ ', 'IndexVector{{ ')

3583

line = line.replace(' }),', ' }}),')

3584

return line.format(**kwargs)

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3585

return line

3586

#

3587

# Process struct validation code for inclusion in function or parent struct validation code

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3588

def expandStructCode(self, lines, funcName, memberNamePrefix, memberDisplayNamePrefix, indent, output, postProcSpec):

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

for line in lines:

if output:

output[-1] += '\n'

if type(line) is list:

3593

for sub in line:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3594

output.append(self.processStructMemberCode(indent + sub, funcName, memberNamePrefix, memberDisplayNamePrefix, postProcSpec))

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3595

else:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3596

output.append(self.processStructMemberCode(indent + line, funcName, memberNamePrefix, memberDisplayNamePrefix, postProcSpec))

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3597

return output

3598

#

3599

# Process struct pointer/array validation code, perfoeming name substitution if required

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3600

def expandStructPointerCode(self, prefix, value, lenValue, funcName, valueDisplayName, postProcSpec):

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3601

expr = []

3602

expr.append('if ({}{} != NULL)\n'.format(prefix, value.name))

3603

expr.append('{')

3604

indent = self.incIndent(None)

3605

if lenValue:

3606

# Need to process all elements in the array

3607

indexName = lenValue.name.replace('Count', 'Index')

3608

expr[-1] += '\n'

3609

expr.append(indent + 'for (uint32_t {iname} = 0; {iname} < {}{}; ++{iname})\n'.format(prefix, lenValue.name, iname=indexName))

3610

expr.append(indent + '{')

3611

indent = self.incIndent(indent)

3612

# Prefix for value name to display in error message

3613

memberNamePrefix = '{}{}[{}].'.format(prefix, value.name, indexName)

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3614

memberDisplayNamePrefix = ('{}[%i].'.format(valueDisplayName), indexName)

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3615

else:

3616

memberNamePrefix = '{}{}->'.format(prefix, value.name)

3617

memberDisplayNamePrefix = '{}->'.format(valueDisplayName)

3618

#

3619

# Expand the struct validation lines

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3620

expr = self.expandStructCode(self.validatedStructs[value.type], funcName, memberNamePrefix, memberDisplayNamePrefix, indent, expr, postProcSpec)

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3621

#

3622

if lenValue:

3623

# Close if and for scopes

3624

indent = self.decIndent(indent)

3625

expr.append(indent + '}\n')

3626

expr.append('}\n')

3627

return expr

3628

#

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3629

# Generate the parameter checking code

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3630

def genFuncBody(self, funcName, values, valuePrefix, displayNamePrefix, structTypeName):

3631

lines = [] # Generated lines of code

3632

unused = [] # Unused variable names

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3633

for value in values:

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3634

usedLines = []

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3635

lenParam = None

3636

#

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3637

# Prefix and suffix for post processing of parameter names for struct members. Arrays of structures need special processing to include the array index in the full parameter name.

3638

postProcSpec = {}

3639

postProcSpec['ppp'] = '' if not structTypeName else '{postProcPrefix}'

3640

postProcSpec['pps'] = '' if not structTypeName else '{postProcSuffix}'

3641

postProcSpec['ppi'] = '' if not structTypeName else '{postProcInsert}'

3642

#

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3643

# Generate the full name of the value, which will be printed in the error message, by adding the variable prefix to the value name

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3644

valueDisplayName = '{}{}'.format(displayNamePrefix, value.name)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3645

#

3646

# Check for NULL pointers, ignore the inout count parameters that

3647

# will be validated with their associated array

3648

if (value.ispointer or value.isstaticarray) and not value.iscount:

3649

#

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3650

# Parameters for function argument generation

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3651

req = 'true' # Paramerter cannot be NULL

3652

cpReq = 'true' # Count pointer cannot be NULL

3653

cvReq = 'true' # Count value cannot be 0

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3654

lenDisplayName = None # Name of length parameter to print with validation messages; parameter name with prefix applied

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3655

#

3656

# Generate required/optional parameter strings for the pointer and count values

3657

if value.isoptional:

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3658

req = 'false'

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3659

if value.len:

3660

# The parameter is an array with an explicit count parameter

3661

lenParam = self.getLenParam(values, value.len)

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3662

lenDisplayName = '{}{}'.format(displayNamePrefix, lenParam.name)

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3663

if lenParam.ispointer:

3664

# Count parameters that are pointers are inout

3665

if type(lenParam.isoptional) is list:

3666

if lenParam.isoptional[0]:

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3667

cpReq = 'false'

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3668

if lenParam.isoptional[1]:

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3669

cvReq = 'false'

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3670

else:

3671

if lenParam.isoptional:

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3672

cpReq = 'false'

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3673

else:

3674

if lenParam.isoptional:

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3675

cvReq = 'false'

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3676

#

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3677

# The parameter will not be processes when tagged as 'noautovalidity'

3678

# For the pointer to struct case, the struct pointer will not be validated, but any

3679

# members not tagged as 'noatuvalidity' will be validated

3680

if value.noautovalidity:

3681

# Log a diagnostic message when validation cannot be automatically generated and must be implemented manually

3682

self.logMsg('diag', 'ParameterValidation: No validation for {} {}'.format(structTypeName if structTypeName else funcName, value.name))

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3683

else:

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3684

#

3685

# If this is a pointer to a struct with an sType field, verify the type

3686

if value.type in self.structTypes:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3687

usedLines += self.makeStructTypeCheck(valuePrefix, value, lenParam, req, cvReq, cpReq, funcName, lenDisplayName, valueDisplayName, postProcSpec)

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3688

# If this is an input handle array that is not allowed to contain NULL handles, verify that none of the handles are VK_NULL_HANDLE

3689

elif value.type in self.handleTypes and value.isconst and not self.isHandleOptional(value, lenParam):

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3690

usedLines += self.makeHandleCheck(valuePrefix, value, lenParam, req, cvReq, funcName, lenDisplayName, valueDisplayName, postProcSpec)

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3691

elif value.type in self.flags and value.isconst:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3692

usedLines += self.makeFlagsArrayCheck(valuePrefix, value, lenParam, req, cvReq, funcName, lenDisplayName, valueDisplayName, postProcSpec)

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3693

elif value.isbool and value.isconst:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3694

usedLines.append('skipCall |= validate_bool32_array(report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, {pf}{}, {pf}{}, {}, {});\n'.format(funcName, lenDisplayName, valueDisplayName, lenParam.name, value.name, cvReq, req, pf=valuePrefix, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3695

elif value.israngedenum and value.isconst:

3696

enumRange = self.enumRanges[value.type]

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3697

usedLines.append('skipCall |= validate_ranged_enum_array(report_data, "{}", {ppp}"{}"{pps}, {ppp}"{}"{pps}, "{}", {}, {}, {pf}{}, {pf}{}, {}, {});\n'.format(funcName, lenDisplayName, valueDisplayName, value.type, enumRange[0], enumRange[1], lenParam.name, value.name, cvReq, req, pf=valuePrefix, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3698

elif value.name == 'pNext':

3699

# We need to ignore VkDeviceCreateInfo and VkInstanceCreateInfo, as the loader manipulates them in a way that is not documented in vk.xml

3700

if not structTypeName in ['VkDeviceCreateInfo', 'VkInstanceCreateInfo']:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3701

usedLines += self.makeStructNextCheck(valuePrefix, value, funcName, valueDisplayName, postProcSpec)

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3702

else:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3703

usedLines += self.makePointerCheck(valuePrefix, value, lenParam, req, cvReq, cpReq, funcName, lenDisplayName, valueDisplayName, postProcSpec)

Dustin Graves

629259b

2016-05-30 16:14:27 -0600

[diff] [blame]

3704

#

3705

# If this is a pointer to a struct (input), see if it contains members that need to be checked

3706

if value.type in self.validatedStructs and value.isconst:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3707

usedLines.append(self.expandStructPointerCode(valuePrefix, value, lenParam, funcName, valueDisplayName, postProcSpec))

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3708

# Non-pointer types

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3709

else:

3710

#

3711

# The parameter will not be processes when tagged as 'noautovalidity'

3712

# For the struct case, the struct type will not be validated, but any

3713

# members not tagged as 'noatuvalidity' will be validated

3714

if value.noautovalidity:

3715

# Log a diagnostic message when validation cannot be automatically generated and must be implemented manually

3716

self.logMsg('diag', 'ParameterValidation: No validation for {} {}'.format(structTypeName if structTypeName else funcName, value.name))

3717

else:

3718

if value.type in self.structTypes:

3719

stype = self.structTypes[value.type]

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3720

usedLines.append('skipCall |= validate_struct_type(report_data, "{}", {ppp}"{}"{pps}, "{sv}", &({}{vn}), {sv}, false);\n'.format(

3721

funcName, valueDisplayName, valuePrefix, vn=value.name, sv=stype.value, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3722

elif value.type in self.handleTypes:

3723

if not self.isHandleOptional(value, None):

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3724

usedLines.append('skipCall |= validate_required_handle(report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3725

elif value.type in self.flags:

3726

flagBitsName = value.type.replace('Flags', 'FlagBits')

3727

if not flagBitsName in self.flagBits:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3728

usedLines.append('skipCall |= validate_reserved_flags(report_data, "{}", {ppp}"{}"{pps}, {pf}{});\n'.format(funcName, valueDisplayName, value.name, pf=valuePrefix, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3729

else:

3730

flagsRequired = 'false' if value.isoptional else 'true'

3731

allFlagsName = 'All' + flagBitsName

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3732

usedLines.append('skipCall |= validate_flags(report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {pf}{}, {});\n'.format(funcName, valueDisplayName, flagBitsName, allFlagsName, value.name, flagsRequired, pf=valuePrefix, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3733

elif value.isbool:

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3734

usedLines.append('skipCall |= validate_bool32(report_data, "{}", {ppp}"{}"{pps}, {}{});\n'.format(funcName, valueDisplayName, valuePrefix, value.name, **postProcSpec))

Dustin Graves

2016-05-16 11:07:59 -0600

[diff] [blame]

3735

elif value.israngedenum:

3736

enumRange = self.enumRanges[value.type]

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3737

usedLines.append('skipCall |= validate_ranged_enum(report_data, "{}", {ppp}"{}"{pps}, "{}", {}, {}, {}{});\n'.format(funcName, valueDisplayName, value.type, enumRange[0], enumRange[1], valuePrefix, value.name, **postProcSpec))

Dustin Graves

629259b

2016-05-30 16:14:27 -0600

[diff] [blame]

3738

#

3739

# If this is a struct, see if it contains members that need to be checked

3740

if value.type in self.validatedStructs:

3741

memberNamePrefix = '{}{}.'.format(valuePrefix, value.name)

3742

memberDisplayNamePrefix = '{}.'.format(valueDisplayName)

Dustin Graves

2016-07-22 13:20:44 -0600

[diff] [blame]

3743

usedLines.append(self.expandStructCode(self.validatedStructs[value.type], funcName, memberNamePrefix, memberDisplayNamePrefix, '', [], postProcSpec))

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3744

#

3745

# Append the parameter check to the function body for the current command

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3746

if usedLines:

Dustin Graves

2016-04-15 18:06:14 -0600

[diff] [blame]

3747

# Apply special conditional checks

3748

if value.condition:

3749

usedLines = self.genConditionalCall(valuePrefix, value.condition, usedLines)

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3750

lines += usedLines

Dustin Graves

2016-03-03 14:17:08 -0700

[diff] [blame]

3751

elif not value.iscount:

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3752

# If no expression was generated for this value, it is unreferenced by the validation function, unless

3753

# it is an array count, which is indirectly referenced for array valiadation.

Dustin Graves

2016-03-03 14:17:08 -0700

[diff] [blame]

3754

unused.append(value.name)

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3755

return lines, unused

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3756

#

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3757

# Generate the struct member check code from the captured data

3758

def processStructMemberData(self):

3759

indent = self.incIndent(None)

3760

for struct in self.structMembers:

Dustin Graves

2016-03-23 19:44:00 -0600

[diff] [blame]

3761

#

3762

# The string returned by genFuncBody will be nested in an if check for a NULL pointer, so needs its indent incremented

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3763

lines, unused = self.genFuncBody('{funcName}', struct.members, '{valuePrefix}', '{displayNamePrefix}', struct.name)

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3764

if lines:

Dustin Graves

2016-04-14 15:03:31 -0600

[diff] [blame]

3765

self.validatedStructs[struct.name] = lines

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3766

#

3767

# Generate the command param check code from the captured data

3768

def processCmdData(self):

3769

indent = self.incIndent(None)

3770

for command in self.commands:

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3771

# Skip first parameter if it is a dispatch handle (everything except vkCreateInstance)

3772

startIndex = 0 if command.name == 'vkCreateInstance' else 1

3773

lines, unused = self.genFuncBody(command.name, command.params[startIndex:], '', '', None)

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3774

if lines:

Dustin Graves

2016-03-02 18:23:29 -0700

[diff] [blame]

3775

cmdDef = self.getCmdDef(command) + '\n'

3776

cmdDef += '{\n'

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3777

# Process unused parameters, Ignoring the first dispatch handle parameter, which is not

3778

# processed by parameter_validation (except for vkCreateInstance, which does not have a

3779

# handle as its first parameter)

3780

if unused:

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3781

for name in unused:

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3782

cmdDef += indent + 'UNUSED_PARAMETER({});\n'.format(name)

Dustin Graves

2016-04-18 18:33:21 -0600

[diff] [blame]

3783

if len(unused) > 0:

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3784

cmdDef += '\n'

Dustin Graves

2016-04-05 13:48:15 -0600

[diff] [blame]

3785

cmdDef += indent + 'bool skipCall = false;\n'

Dustin Graves

2016-04-11 16:06:25 -0600

[diff] [blame]

3786

for line in lines:

3787

cmdDef += '\n'

3788

if type(line) is list:

3789

for sub in line:

3790

cmdDef += indent + sub

3791

else:

3792

cmdDef += indent + line

Dustin Graves