505 lines
17 KiB
Plaintext
505 lines
17 KiB
Plaintext
# Copyright (c) 2013-2018 The Khronos Group Inc.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
|
|
# Relax NG schema for Khronos Vulkan API Registry XML
|
|
#
|
|
# See https://www.khronos.org/vulkan/
|
|
#
|
|
# This definition is subject to change (mostly in the form of additions)
|
|
|
|
namespace xsd = "http://www.w3.org/2001/XMLSchema-datatypes"
|
|
|
|
# Toplevel is a <registry> tag.
|
|
# May be led by an optional <comment> tag containing e.g. copyrights.
|
|
start = element registry {
|
|
(
|
|
element comment { text } ? |
|
|
Vendorids * |
|
|
Platforms * |
|
|
Tags * |
|
|
Types * |
|
|
Enums * |
|
|
Commands * |
|
|
Feature * |
|
|
Extensions *
|
|
) *
|
|
}
|
|
|
|
# <vendorids> defines a group of vendor IDs
|
|
Vendorids = element vendorids {
|
|
Comment ? ,
|
|
Vendorid *
|
|
}
|
|
|
|
# <vendorid> defines a single vendor ID.
|
|
# name - author ID of the vendor
|
|
# id - Khronos vendor ID (hexadecimal constant starting at 0x10000)
|
|
# comment - unused
|
|
Vendorid = element vendorid {
|
|
attribute name { text } ,
|
|
attribute id { text } ,
|
|
Comment ?
|
|
}
|
|
|
|
# <platforms> defines a group of platform names
|
|
Platforms = element platforms {
|
|
Comment ? ,
|
|
Platform *
|
|
}
|
|
|
|
# <platform> defines a single platform name.
|
|
# name - string name of the platform, used as part of extension names
|
|
# protect - preprocessor symbol to include platform headers from <vulkan.h>
|
|
# comment - platform description
|
|
Platform = element platform {
|
|
attribute name { text } ,
|
|
attribute protect { text } ,
|
|
Comment
|
|
}
|
|
|
|
# <tags> defines a group of author tags
|
|
Tags = element tags {
|
|
Comment ? ,
|
|
Tag *
|
|
}
|
|
|
|
# <tag> defines a single author tag.
|
|
# name - name of the tag
|
|
# author - name of the author (usually a company or project name)
|
|
# contact - contact responsible for the tag (name and contact information)
|
|
Tag = element tag {
|
|
attribute name { text } ,
|
|
attribute author { text } ,
|
|
attribute contact { text }
|
|
}
|
|
|
|
# <types> defines a group of types
|
|
Types = element types {
|
|
Comment ? ,
|
|
(
|
|
Type |
|
|
element comment { text }
|
|
) *
|
|
}
|
|
|
|
# <type> defines a single type. It is usually a C typedef but
|
|
# may contain arbitrary C code.
|
|
# name - name of this type, if not present in the <name> tag
|
|
# api - matches a <feature> api attribute, if present
|
|
# requires - name of another type definition required by this one
|
|
# category - if present, 'enum' indicates a matching <enums>
|
|
# block to generate an enumerated type for, and 'struct'
|
|
# causes special interpretation of the contents of the type
|
|
# tag including ... TBD ...
|
|
# Other allowed values are 'include', 'define', 'handle' and 'bitmask',
|
|
# which don't change syntactic interpretation but allow organization in
|
|
# the generated header.
|
|
# comment - unused
|
|
# parent - only applicable if category is 'handle'. Notes another type with
|
|
# the 'handle' category that acts as a parent object for this type.
|
|
# returnedonly - only applicable if category is 'struct'. Notes that this
|
|
# struct is going to be filled in by the API, rather than an application
|
|
# filling it out and passing it to the API.
|
|
# structextends - only applicable if category is 'struct'. Lists parent
|
|
# structures which this structure may extend via the pNext chain
|
|
# of the parent.
|
|
# When present it suppresses generation of automatic validity for the
|
|
# pNext member of that structure, and instead the structure is added
|
|
# to pNext chain validity for the parent structures it extends.
|
|
# For types without a category, contents include
|
|
# <apientry /> - substitutes for an APIENTRY-style macro on output
|
|
# <name> - contains name of the type being defined
|
|
# <type> - contains name of types used to define this type. There
|
|
# may be multiple imbedded <type> tags
|
|
# For types with category 'enum', contents should be empty
|
|
# For types with category 'struct', contents should be one or more
|
|
# <member> - like <param> for a struct or union member
|
|
# len - if the member is an array, len may be one or more of the following
|
|
# things, separated by commas (one for each array indirection): another
|
|
# member of that struct, 'null-terminated' for a string, '1' to indicate it's
|
|
# just a pointer (used for nested pointers), or a latex equation (prefixed with
|
|
# 'latexmath:')
|
|
# altlen - if len has latexmath equations, this contains equivalent C99
|
|
# expressions separated by commas.
|
|
# externsync - denotes that the member should be externally synchronized
|
|
# when accessed by Vulkan
|
|
# optional - whether this value can be omitted by providing NULL (for
|
|
# pointers), VK_NULL_HANDLE (for handles) or 0 (for bitmasks/values)
|
|
# noautovalidity - tag stating that no automatic validity language should be generated
|
|
# values - comma-separated list of legal values, usually used only for sType enums
|
|
# <comment> - containing arbitrary text (unused)
|
|
#
|
|
# *** There's a problem here: I'm not sure how to represent the <type>
|
|
# syntax where it may contain arbitrarily interleaved text, <type>, and
|
|
# <enum> child tags. This allows only the syntax
|
|
# text <type>name</type> text <enum>name</enum> text
|
|
# where <type> and <enum> are both optional and occur in the specified
|
|
# order, which might eventually be a problem.
|
|
Type = element type {
|
|
attribute api { text } ? ,
|
|
attribute alias { text } ? ,
|
|
attribute requires { text } ? ,
|
|
attribute name { TypeName } ? ,
|
|
attribute category { text } ? ,
|
|
attribute parent { TypeName } ? ,
|
|
attribute returnedonly { text } ? ,
|
|
attribute structextends { text } ? ,
|
|
Comment ? ,
|
|
(
|
|
(
|
|
( text ,
|
|
element type { text } *
|
|
) * ,
|
|
element apientry { text } ? ,
|
|
( text ,
|
|
element type { text } *
|
|
) * ,
|
|
element name { TypeName } ? ,
|
|
( text ,
|
|
element type { text } *
|
|
) *
|
|
) |
|
|
(
|
|
element member {
|
|
attribute len { text } ? ,
|
|
attribute altlen { text } ? ,
|
|
attribute externsync { text } ? ,
|
|
attribute optional { text } ? ,
|
|
attribute noautovalidity { text } ? ,
|
|
attribute values { text } ? ,
|
|
mixed {
|
|
element type { TypeName } ? ,
|
|
element name { text } ,
|
|
element enum { EnumName } ? ,
|
|
element comment { text } ?
|
|
}
|
|
} |
|
|
element comment { text }
|
|
) *
|
|
)
|
|
}
|
|
|
|
# <enums> defines a group of enumerants
|
|
# name - identifies a type name associated with this group. Should
|
|
# match a <type> name to trigger generation of the type.
|
|
# start, end - beginning and end of a numeric range
|
|
# vendor - owner of the numeric range
|
|
# type - 'enum' or 'bitmask', if present
|
|
# comment - unused
|
|
Enums = element enums {
|
|
attribute name { text } ? ,
|
|
attribute type { text } ? ,
|
|
attribute start { Integer } ? ,
|
|
attribute end { Integer } ? ,
|
|
Vendor ? ,
|
|
Comment ? ,
|
|
(
|
|
Enum |
|
|
Unused |
|
|
element comment { text}
|
|
) *
|
|
}
|
|
|
|
# <enum> defines or references a single enumerant. There are two places it
|
|
# can be used: in an <enums> block, providing a global definition which
|
|
# may later be required by a feature or extension; or in a feature or
|
|
# extension, defining an enumerant specific to that feature. The second
|
|
# form has more possible attributes. Some combinations of attributes are
|
|
# nonsensical in on or the other place, but these are not detected by the
|
|
# validator.
|
|
#
|
|
# Ways to specify the enumerant value:
|
|
# value - integer (including hex) value of the enumerant
|
|
# bitpos - integer bit position of the enumerant in a bitmask
|
|
# [extnumber], offset, [dir] - integer extension number specifying a
|
|
# base block value (inherited from surrounding <extension> if
|
|
# not specified); integer offset in that block; and direction
|
|
# of offset ('-' for negative, positive if not specified).
|
|
# alias - name of another enum this is an alias of
|
|
#
|
|
# value and bitpos allow, and extnumber/offset/dir require:
|
|
# extends - type name of the enumerant being extended
|
|
#
|
|
# Other attributes:
|
|
# api - matches a <feature> api attribute, if present
|
|
# type - 'u' (unsigned), 'ull' (uint64), or integer if not present
|
|
# name - enumerant name
|
|
# alias - another enumerant this is semantically identical to
|
|
# comment - unused
|
|
Enum = element enum {
|
|
(
|
|
(
|
|
(
|
|
attribute value { Integer } &
|
|
attribute extends { TypeName } ?
|
|
) |
|
|
(
|
|
attribute bitpos { Integer } &
|
|
attribute extends { TypeName } ?
|
|
) |
|
|
(
|
|
attribute extnumber { Integer } ? &
|
|
attribute offset { Integer } &
|
|
attribute dir { text } ? &
|
|
attribute extends { TypeName }
|
|
) |
|
|
(
|
|
attribute extends { TypeName } ? &
|
|
attribute alias { TypeName }
|
|
)
|
|
) ? &
|
|
attribute api { text } ? &
|
|
attribute type { TypeSuffix } ? &
|
|
attribute name { text } &
|
|
Comment ?
|
|
)
|
|
}
|
|
|
|
# <unused> defines a range of enumerants not currently being used
|
|
# start, end - beginning and end of an unused numeric range
|
|
# vendor - unused
|
|
# comment - unused
|
|
Unused = element unused {
|
|
attribute start { Integer } ,
|
|
attribute end { Integer } ? ,
|
|
Vendor ? ,
|
|
Comment ?
|
|
}
|
|
# <commands> defines a group of commands
|
|
Commands = element commands {
|
|
Comment ? ,
|
|
Command *
|
|
}
|
|
|
|
# <command> defines a single command
|
|
#
|
|
# There are two forms of the tag.
|
|
#
|
|
# The first only has 'name' and 'alias' attributes, and no contents.
|
|
# It defines a command alias.
|
|
#
|
|
# The second fully defines a command, and has the following structure:
|
|
# The possible attributes are not described in this comment block yet, but
|
|
# are in readme.pdf.
|
|
#
|
|
# <proto> is the C function prototype, including the return type
|
|
# <param> are function parameters, in order
|
|
# len - if the member is an array, len may be one or more of the following
|
|
# things, separated by commas (one for each array indirection): another
|
|
# member of that struct, 'null-terminated' for a string, '1' to indicate it's
|
|
# just a pointer (used for nested pointers), or a latex equation (prefixed with
|
|
# 'latexmath:')
|
|
# altlen - if len has latexmath equations, this contains equivalent C99
|
|
# expressions separated by commas.
|
|
# externsync - denotes that the member should be externally synchronized
|
|
# when accessed by Vulkan
|
|
# optional - whether this value can be omitted by providing NULL (for
|
|
# pointers), VK_NULL_HANDLE (for handles) or 0 (for bitmasks/values)
|
|
# noautovalidity - tag stating that no automatic validity language should be generated
|
|
# <type> is a <type> name, if present
|
|
# <name> is the function / parameter name
|
|
# The textual contents of <proto> and <param> should be legal C
|
|
# for those parts of a function declaration.
|
|
# <alias> - denotes function aliasing, if present
|
|
# name - name of aliased function
|
|
# <description> - unused text
|
|
# <implicitexternsyncparams> are spec-language descriptions of
|
|
# objects that are not parameters of the command, but
|
|
# are related to them and also require external synchronization.
|
|
Command = element command {
|
|
( attribute name { text } ,
|
|
attribute alias { text } ) |
|
|
(
|
|
attribute queues { text } ? ,
|
|
attribute successcodes { text } ? ,
|
|
attribute errorcodes { text } ? ,
|
|
attribute renderpass { text } ? ,
|
|
attribute cmdbufferlevel { text } ? ,
|
|
attribute pipeline { text } ? ,
|
|
Comment ? ,
|
|
element proto {
|
|
mixed {
|
|
element type { TypeName } ? ,
|
|
element name { text }
|
|
}
|
|
} ,
|
|
element param {
|
|
attribute len { text } ? ,
|
|
attribute altlen { text } ? ,
|
|
attribute externsync { text } ? ,
|
|
attribute optional { text } ? ,
|
|
attribute noautovalidity { text } ? ,
|
|
mixed {
|
|
element type { TypeName } ? ,
|
|
element name { text }
|
|
}
|
|
} * ,
|
|
(
|
|
element alias {
|
|
Name
|
|
} ? &
|
|
element description {
|
|
text
|
|
} ? &
|
|
element implicitexternsyncparams {
|
|
element param { text } *
|
|
} ?
|
|
)
|
|
)
|
|
}
|
|
|
|
# Each <feature> defines the interface of an API version (e.g. OpenGL 1.2)
|
|
# api - API tag (e.g. 'gl', 'gles2', etc. - used internally, not
|
|
# necessarily an actual API name
|
|
# name - version name (C preprocessor name, e.g. GL_VERSION_4_2)
|
|
# number - version number, e.g. 4.2
|
|
# protect - additional #ifdef symbol to place around the feature
|
|
# <require> / <remove> contains features to require or remove in
|
|
# this version
|
|
# profile - only require/remove when generated profile matches
|
|
# comment - unused
|
|
Feature = element feature {
|
|
attribute api { text } ,
|
|
Name ,
|
|
attribute number { xsd:float } ,
|
|
attribute protect { text } ? ,
|
|
Comment ? ,
|
|
(
|
|
element require {
|
|
ProfileName ? ,
|
|
ExtensionName ? ,
|
|
Comment ? ,
|
|
(
|
|
InterfaceElement |
|
|
element comment { text }
|
|
) *
|
|
} |
|
|
element remove {
|
|
ProfileName ? ,
|
|
Comment ? ,
|
|
(
|
|
InterfaceElement |
|
|
element comment { text }
|
|
) *
|
|
}
|
|
) *
|
|
}
|
|
|
|
Extensions = element extensions {
|
|
Comment ? ,
|
|
Extension *
|
|
}
|
|
|
|
# Defines the interface of an API <extension>. Like a <feature>
|
|
# tag, but with slightly different attributes:
|
|
# api - regexp pattern matching one or more API tags, indicating
|
|
# which APIs the extension is known to work with. The only
|
|
# syntax supported is <name>{|<name>}* and each name must
|
|
# exactly match an API being generated (implicit ^$ surrounding).
|
|
# name - extension name string
|
|
# number - extension number (positive integer, should be unique)
|
|
# protect - C preprocessor symbol to conditionally define the interface
|
|
# platform - should be one of the platform names defined in the
|
|
# <platform> tag. Currently unused.
|
|
# author - name of the author (usually a company or project name)
|
|
# contact - contact responsible for the tag (name and contact information)
|
|
# type - 'device' or 'instance', if present
|
|
# requires - commas-separated list of extension names required by this
|
|
# extension
|
|
# requiresCore - core version of Vulkan required by the extension, e.g.
|
|
# "1.1". Defaults to "1.0".
|
|
# supported - profile name(s) supporting this extension, e.g. 'vulkan'
|
|
# or 'disabled' to never generate output.
|
|
# In addition, <require> / <remove> tags also support an api attribute:
|
|
# api - only require/remove these features for the matching API.
|
|
# Not a regular expression.
|
|
Extension = element extension {
|
|
Name ,
|
|
attribute number { Integer } ? ,
|
|
attribute protect { text } ? ,
|
|
attribute platform { text } ? ,
|
|
attribute author { text } ? ,
|
|
attribute contact { text } ? ,
|
|
attribute type { text } ? ,
|
|
attribute requires { text } ? ,
|
|
attribute requiresCore { text } ? ,
|
|
attribute supported { StringGroup } ? ,
|
|
Comment ? ,
|
|
(
|
|
element require {
|
|
attribute api { text } ? ,
|
|
ProfileName ? ,
|
|
ExtensionName ? ,
|
|
FeatureName ? ,
|
|
Comment ? ,
|
|
(
|
|
InterfaceElement |
|
|
element comment { text }
|
|
) *
|
|
} |
|
|
element remove {
|
|
attribute api { text } ? ,
|
|
ProfileName ? ,
|
|
Comment ? ,
|
|
(
|
|
InterfaceElement |
|
|
element comment { text }
|
|
) *
|
|
}
|
|
) *
|
|
}
|
|
|
|
# Contents of a <require> / <remove> tag, defining a group
|
|
# of features to require or remove.
|
|
# <type> / <enum> / <command> all have attributes
|
|
# name - feature name which must match
|
|
InterfaceElement =
|
|
element type {
|
|
Name ,
|
|
Comment ?
|
|
} |
|
|
Enum |
|
|
element command {
|
|
Name ,
|
|
Comment ?
|
|
}
|
|
|
|
# Integers are allowed to be either decimal or C-hex (0x[0-9A-F]+), but
|
|
# XML Schema types don't seem to support hex notation, so we use this
|
|
# as a placeholder.
|
|
Integer = text
|
|
|
|
# EnumName is an compile-time constant name
|
|
EnumName = text
|
|
|
|
# TypeName is an argument/return value C type name
|
|
TypeName = text
|
|
|
|
# TypeSuffix is a C numeric type suffix, e.g. 'u' or 'ull'
|
|
TypeSuffix = text
|
|
|
|
# StringGroup is a regular expression with an implicit
|
|
# '^(' and ')$' bracketing it.
|
|
StringGroup = text
|
|
|
|
# Repeatedly used attributes
|
|
ProfileName = attribute profile { text }
|
|
ExtensionName = attribute extension { text }
|
|
FeatureName = attribute feature { text }
|
|
Vendor = attribute vendor { text }
|
|
Comment = attribute comment { text }
|
|
Name = attribute name { text }
|
|
|
|
|