module Data.SpirV.Reflect.Yaml.Parsers where

import Prelude hiding (id)

import Control.Applicative ((<|>))
import Data.Functor ((<&>))
import Data.Maybe (catMaybes)
import Data.SpirV.Enum qualified as SpirV
import Data.Text (Text)
import Data.Vector (Vector)
import Data.Vector qualified as Vector
import Data.Vector.Storable qualified as Storable
import Data.YAML ((.:))
import Data.YAML qualified as YAML

import Data.SpirV.Reflect.BlockVariable (BlockVariable)
import Data.SpirV.Reflect.BlockVariable qualified as BlockVariable
import Data.SpirV.Reflect.DescriptorBinding (DescriptorBinding)
import Data.SpirV.Reflect.DescriptorBinding qualified as DescriptorBinding
import Data.SpirV.Reflect.DescriptorSet (DescriptorSet)
import Data.SpirV.Reflect.DescriptorSet qualified as DescriptorSet
import Data.SpirV.Reflect.Enums qualified as Reflect
import Data.SpirV.Reflect.InterfaceVariable (InterfaceVariable)
import Data.SpirV.Reflect.InterfaceVariable qualified as InterfaceVariable
import Data.SpirV.Reflect.Module (Module)
import Data.SpirV.Reflect.Module qualified as Module
import Data.SpirV.Reflect.SpecializationConstant (SpecializationConstant)
import Data.SpirV.Reflect.SpecializationConstant qualified as SpecializationConstant
import Data.SpirV.Reflect.Traits qualified as Traits
import Data.SpirV.Reflect.TypeDescription (TypeDescription)
import Data.SpirV.Reflect.TypeDescription qualified as TypeDescription

rootP :: NodeParser Module
rootP :: NodeParser Module
rootP = String -> (Mapping Pos -> Parser Module) -> NodeParser Module
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Root" \Mapping Pos
m ->
  -- XXX: Discarding all_XXX fields, assuming they got unrolled by YAML decoder.
  Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"module" Parser (Node Pos) -> NodeParser Module -> Parser Module
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NodeParser Module
moduleP

moduleP :: NodeParser Module
moduleP :: NodeParser Module
moduleP = String -> (Mapping Pos -> Parser Module) -> NodeParser Module
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Module" \Mapping Pos
m -> do
  Generator
generator               <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"generator" Parser Int -> (Int -> Generator) -> Parser Generator
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int -> Generator
Reflect.Generator
  Text
entry_point_name        <- Mapping Pos
m Mapping Pos -> Text -> Parser Text
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"entry_point_name"
  Int
entry_point_id          <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"entry_point_id"
  Int
source_language         <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"source_language"
  Int
source_language_version <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"source_language_version"
  Int
spirv_execution_model   <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"spirv_execution_model"
  Int
shader_stage            <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"shader_stage"
  Vector DescriptorBinding
descriptor_bindings     <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"descriptor_bindings" Parser (Maybe (Node Pos))
-> NodeParser DescriptorBinding
-> Parser (Vector DescriptorBinding)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser DescriptorBinding
descriptorBindingP
  Vector DescriptorSet
descriptor_sets         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"descriptor_sets" Parser (Maybe (Node Pos))
-> NodeParser DescriptorSet -> Parser (Vector DescriptorSet)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser DescriptorSet
descriptorSetP
  Vector InterfaceVariable
input_variables         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"input_variables" Parser (Maybe (Node Pos))
-> NodeParser InterfaceVariable
-> Parser (Vector InterfaceVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser InterfaceVariable
interfaceVariableP
  Vector InterfaceVariable
output_variables        <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"output_variables" Parser (Maybe (Node Pos))
-> NodeParser InterfaceVariable
-> Parser (Vector InterfaceVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser InterfaceVariable
interfaceVariableP
  Vector BlockVariable
push_constants          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"push_constants" Parser (Maybe (Node Pos))
-> NodeParser BlockVariable -> Parser (Vector BlockVariable)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser BlockVariable
blockVariableP
  Vector SpecializationConstant
spec_constants          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spec_constants" Parser (Maybe (Node Pos))
-> NodeParser SpecializationConstant
-> Parser (Vector SpecializationConstant)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser SpecializationConstant
specializationConstantP
  pure Module.Module{Int
Text
Generator
Vector SpecializationConstant
Vector InterfaceVariable
Vector BlockVariable
Vector DescriptorBinding
Vector DescriptorSet
generator :: Generator
entry_point_name :: Text
entry_point_id :: Int
source_language :: Int
source_language_version :: Int
spirv_execution_model :: Int
shader_stage :: Int
descriptor_bindings :: Vector DescriptorBinding
descriptor_sets :: Vector DescriptorSet
input_variables :: Vector InterfaceVariable
output_variables :: Vector InterfaceVariable
push_constants :: Vector BlockVariable
spec_constants :: Vector SpecializationConstant
$sel:generator:Module :: Generator
$sel:entry_point_name:Module :: Text
$sel:entry_point_id:Module :: Int
$sel:source_language:Module :: Int
$sel:source_language_version:Module :: Int
$sel:spirv_execution_model:Module :: Int
$sel:shader_stage:Module :: Int
$sel:descriptor_bindings:Module :: Vector DescriptorBinding
$sel:descriptor_sets:Module :: Vector DescriptorSet
$sel:input_variables:Module :: Vector InterfaceVariable
$sel:output_variables:Module :: Vector InterfaceVariable
$sel:push_constants:Module :: Vector BlockVariable
$sel:spec_constants:Module :: Vector SpecializationConstant
..}

descriptorBindingP :: NodeParser DescriptorBinding
descriptorBindingP :: NodeParser DescriptorBinding
descriptorBindingP = String
-> (Mapping Pos -> Parser DescriptorBinding)
-> NodeParser DescriptorBinding
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"DescriptorBinding" \Mapping Pos
m -> do
  Maybe Word32
spirv_id                    <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Text
name                        <- Mapping Pos
m Mapping Pos -> Text -> Parser Text
forall a. (FromYAML a, Monoid a) => Mapping Pos -> Text -> Parser a
.| Text
"name"
  Word32
binding                     <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"binding"
  Word32
input_attachment_index      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"input_attachment_index"
  Word32
set                         <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"set"
  DescriptorType
descriptor_type             <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"descriptor_type" Parser Int -> (Int -> DescriptorType) -> Parser DescriptorType
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int -> DescriptorType
Reflect.DescriptorType
  ResourceFlagBits
resource_type               <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"resource_type" Parser Word32
-> (Word32 -> ResourceFlagBits) -> Parser ResourceFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Word32 -> ResourceFlagBits
Reflect.ResourceFlagBits
  Image
image                       <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"image" Parser (Node Pos) -> (Node Pos -> Parser Image) -> Parser Image
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Image
traitsImageP
  Maybe BlockVariable
block                       <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"block" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe BlockVariable))
-> Parser (Maybe BlockVariable)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NodeParser BlockVariable
-> Maybe (Node Pos) -> Parser (Maybe BlockVariable)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse NodeParser BlockVariable
blockVariableP
  Array
array                       <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  Maybe Word32
count                       <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"count"
  Word32
accessed                    <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"accessed"
  Word32
uav_counter_id              <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"uav_counter_id"
  Maybe DescriptorBinding
uav_counter_binding         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"uav_counter_binding" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe DescriptorBinding))
-> Parser (Maybe DescriptorBinding)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NodeParser DescriptorBinding
-> Maybe (Node Pos) -> Parser (Maybe DescriptorBinding)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse NodeParser DescriptorBinding
descriptorBindingP
  Vector Word32
byte_address_buffer_offsets <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"byte_address_buffer_offsets" Parser (Maybe (Node Pos))
-> NodeParser Word32 -> Parser (Vector Word32)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` String -> (Integer -> Parser Word32) -> NodeParser Word32
forall a. String -> (Integer -> Parser a) -> Node Pos -> Parser a
YAML.withInt String
"byte_address_buffer_offset" (Word32 -> Parser Word32
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word32 -> Parser Word32)
-> (Integer -> Word32) -> Integer -> Parser Word32
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Word32
forall a. Num a => Integer -> a
fromInteger)
  Maybe TypeDescription
type_description            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  WordOffset
word_offset                 <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"word_offset" Parser (Node Pos)
-> (Node Pos -> Parser WordOffset) -> Parser WordOffset
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser WordOffset
descriptorBindingWordOffsetP
  DecorationFlagBits
decoration_flags            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"decoration_flags" Parser (Maybe Word32)
-> (Maybe Word32 -> DecorationFlagBits)
-> Parser DecorationFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> DecorationFlagBits
-> (Word32 -> DecorationFlagBits)
-> Maybe Word32
-> DecorationFlagBits
forall b a. b -> (a -> b) -> Maybe a -> b
maybe DecorationFlagBits
Reflect.DECORATION_NONE Word32 -> DecorationFlagBits
Reflect.DecorationFlagBits
  Maybe UserType
user_type                   <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"user_type" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe UserType))
-> Parser (Maybe UserType)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser UserType)
-> Maybe (Node Pos) -> Parser (Maybe UserType)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser UserType
userTypeP
  pure DescriptorBinding.DescriptorBinding{Maybe Word32
Maybe UserType
Maybe TypeDescription
Maybe BlockVariable
Maybe DescriptorBinding
Word32
Text
DecorationFlagBits
DescriptorType
ResourceFlagBits
Image
Array
WordOffset
Vector Word32
spirv_id :: Maybe Word32
name :: Text
binding :: Word32
input_attachment_index :: Word32
set :: Word32
descriptor_type :: DescriptorType
resource_type :: ResourceFlagBits
image :: Image
block :: Maybe BlockVariable
array :: Array
count :: Maybe Word32
accessed :: Word32
uav_counter_id :: Word32
uav_counter_binding :: Maybe DescriptorBinding
byte_address_buffer_offsets :: Vector Word32
type_description :: Maybe TypeDescription
word_offset :: WordOffset
decoration_flags :: DecorationFlagBits
user_type :: Maybe UserType
$sel:spirv_id:DescriptorBinding :: Maybe Word32
$sel:name:DescriptorBinding :: Text
$sel:binding:DescriptorBinding :: Word32
$sel:input_attachment_index:DescriptorBinding :: Word32
$sel:set:DescriptorBinding :: Word32
$sel:descriptor_type:DescriptorBinding :: DescriptorType
$sel:resource_type:DescriptorBinding :: ResourceFlagBits
$sel:image:DescriptorBinding :: Image
$sel:block:DescriptorBinding :: Maybe BlockVariable
$sel:array:DescriptorBinding :: Array
$sel:count:DescriptorBinding :: Maybe Word32
$sel:accessed:DescriptorBinding :: Word32
$sel:uav_counter_id:DescriptorBinding :: Word32
$sel:uav_counter_binding:DescriptorBinding :: Maybe DescriptorBinding
$sel:byte_address_buffer_offsets:DescriptorBinding :: Vector Word32
$sel:type_description:DescriptorBinding :: Maybe TypeDescription
$sel:word_offset:DescriptorBinding :: WordOffset
$sel:decoration_flags:DescriptorBinding :: DecorationFlagBits
$sel:user_type:DescriptorBinding :: Maybe UserType
..}

userTypeP :: NodeParser Reflect.UserType
userTypeP :: Node Pos -> Parser UserType
userTypeP = String -> (Text -> Parser UserType) -> Node Pos -> Parser UserType
forall a. String -> (Text -> Parser a) -> Node Pos -> Parser a
YAML.withStr String
"UserType" ((Text -> Parser UserType) -> Node Pos -> Parser UserType)
-> (Text -> Parser UserType) -> Node Pos -> Parser UserType
forall a b. (a -> b) -> a -> b
$ Parser UserType
-> (UserType -> Parser UserType)
-> Maybe UserType
-> Parser UserType
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> Parser UserType
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Unknown UserType") UserType -> Parser UserType
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Maybe UserType -> Parser UserType)
-> (Text -> Maybe UserType) -> Text -> Parser UserType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Maybe UserType
forall label. (Eq label, IsString label) => label -> Maybe UserType
Reflect.userTypeId

descriptorBindingWordOffsetP :: NodeParser DescriptorBinding.WordOffset
descriptorBindingWordOffsetP :: Node Pos -> Parser WordOffset
descriptorBindingWordOffsetP = String
-> (Mapping Pos -> Parser WordOffset)
-> Node Pos
-> Parser WordOffset
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"DescriptorBinding.WordOffset" \Mapping Pos
m -> do
  Word32
binding <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"binding"
  Word32
set     <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"set"
  pure DescriptorBinding.WordOffset{Word32
binding :: Word32
set :: Word32
$sel:binding:WordOffset :: Word32
$sel:set:WordOffset :: Word32
..}

typeDescriptionP :: NodeParser TypeDescription
typeDescriptionP :: Node Pos -> Parser TypeDescription
typeDescriptionP = String
-> (Mapping Pos -> Parser TypeDescription)
-> Node Pos
-> Parser TypeDescription
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"TypeDescription" \Mapping Pos
m -> do
  Maybe Word32
id                      <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"id"
  Maybe Op
op                      <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Int32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"op" Parser (Maybe Int32)
-> (Maybe Int32 -> Maybe Op) -> Parser (Maybe Op)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Int32 -> Op) -> Maybe Int32 -> Maybe Op
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int32 -> Op
SpirV.Op
  Maybe Text
type_name               <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_name"
  Maybe Text
struct_member_name      <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"struct_member_name"
  StorageClass
storage_class           <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"storage_class" Parser Int32 -> (Int32 -> StorageClass) -> Parser StorageClass
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> StorageClass
SpirV.StorageClass
  TypeFlagBits
type_flags              <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_flags" Parser (Maybe Word32)
-> (Maybe Word32 -> TypeFlagBits) -> Parser TypeFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> TypeFlagBits
-> (Word32 -> TypeFlagBits) -> Maybe Word32 -> TypeFlagBits
forall b a. b -> (a -> b) -> Maybe a -> b
maybe TypeFlagBits
Reflect.TYPE_FLAG_UNDEFINED Word32 -> TypeFlagBits
Reflect.TypeFlagBits
  Maybe Traits
traits                  <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"traits" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe Traits))
-> Parser (Maybe Traits)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser Traits)
-> Maybe (Node Pos) -> Parser (Maybe Traits)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser Traits
typeDescriptionTraitsP Parser (Maybe Traits)
-> (Maybe Traits -> Maybe Traits) -> Parser (Maybe Traits)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe Traits
ts -> if Maybe Traits
ts Maybe Traits -> Maybe Traits -> Bool
forall a. Eq a => a -> a -> Bool
== Traits -> Maybe Traits
forall a. a -> Maybe a
Just Traits
TypeDescription.emptyTraits then Maybe Traits
forall a. Maybe a
Nothing else Maybe Traits
ts
  Maybe Word32
copied                  <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"copied" -- BUG: YAML has no "copied" field
  Vector TypeDescription
members                 <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"members" Parser (Maybe (Node Pos))
-> NodeParser (Maybe TypeDescription)
-> Parser (Vector TypeDescription)
forall a.
Parser (Maybe (Node Pos))
-> NodeParser (Maybe a) -> Parser (Vector a)
`seqOfMaybes` NodeParser (Maybe TypeDescription)
-> NodeParser (Maybe TypeDescription)
-> NodeParser (Maybe TypeDescription)
forall a. NodeParser a -> NodeParser a -> NodeParser a
alt NodeParser (Maybe TypeDescription)
forall a. NodeParser (Maybe a)
forwardPointerP ((TypeDescription -> Maybe TypeDescription)
-> Parser TypeDescription -> Parser (Maybe TypeDescription)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap TypeDescription -> Maybe TypeDescription
forall a. a -> Maybe a
Just (Parser TypeDescription -> Parser (Maybe TypeDescription))
-> (Node Pos -> Parser TypeDescription)
-> NodeParser (Maybe TypeDescription)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Node Pos -> Parser TypeDescription
typeDescriptionP) -- BUG: YAML uses `[forward pointer]` marker for recursive structures.
  Maybe TypeDescription
struct_type_description <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"struct_type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  pure TypeDescription.TypeDescription{Maybe Word32
Maybe Text
Maybe Op
Maybe Traits
Maybe TypeDescription
StorageClass
TypeFlagBits
Vector TypeDescription
id :: Maybe Word32
op :: Maybe Op
type_name :: Maybe Text
struct_member_name :: Maybe Text
storage_class :: StorageClass
type_flags :: TypeFlagBits
traits :: Maybe Traits
copied :: Maybe Word32
members :: Vector TypeDescription
struct_type_description :: Maybe TypeDescription
$sel:id:TypeDescription :: Maybe Word32
$sel:op:TypeDescription :: Maybe Op
$sel:type_name:TypeDescription :: Maybe Text
$sel:struct_member_name:TypeDescription :: Maybe Text
$sel:storage_class:TypeDescription :: StorageClass
$sel:type_flags:TypeDescription :: TypeFlagBits
$sel:traits:TypeDescription :: Maybe Traits
$sel:struct_type_description:TypeDescription :: Maybe TypeDescription
$sel:copied:TypeDescription :: Maybe Word32
$sel:members:TypeDescription :: Vector TypeDescription
..}

typeDescriptionTraitsP :: NodeParser TypeDescription.Traits
typeDescriptionTraitsP :: Node Pos -> Parser Traits
typeDescriptionTraitsP = String
-> (Mapping Pos -> Parser Traits) -> Node Pos -> Parser Traits
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"TypeDescription.Traits" \Mapping Pos
m -> do
  Numeric
numeric <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"numeric" Parser (Node Pos) -> (Node Pos -> Parser Numeric) -> Parser Numeric
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Numeric
traitsNumericP
  Image
image   <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"image" Parser (Node Pos) -> (Node Pos -> Parser Image) -> Parser Image
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Image
traitsImageP
  Array
array   <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  pure TypeDescription.Traits{Image
Array
Numeric
numeric :: Numeric
image :: Image
array :: Array
$sel:numeric:Traits :: Numeric
$sel:image:Traits :: Image
$sel:array:Traits :: Array
..}

descriptorSetP :: NodeParser DescriptorSet
descriptorSetP :: NodeParser DescriptorSet
descriptorSetP = String
-> (Mapping Pos -> Parser DescriptorSet)
-> NodeParser DescriptorSet
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"DescriptorSet" \Mapping Pos
m -> do
  Word32
set <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"set"
  Vector DescriptorBinding
bindings <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"bindings" Parser (Maybe (Node Pos))
-> NodeParser DescriptorBinding
-> Parser (Vector DescriptorBinding)
forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
`seqOf` NodeParser DescriptorBinding
descriptorBindingP
  pure DescriptorSet.DescriptorSet{Word32
Vector DescriptorBinding
set :: Word32
bindings :: Vector DescriptorBinding
$sel:set:DescriptorSet :: Word32
$sel:bindings:DescriptorSet :: Vector DescriptorBinding
..}

interfaceVariableP :: NodeParser InterfaceVariable
interfaceVariableP :: NodeParser InterfaceVariable
interfaceVariableP = String
-> (Mapping Pos -> Parser InterfaceVariable)
-> NodeParser InterfaceVariable
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"InterfaceVariable" \Mapping Pos
m -> do
  Maybe Word32
spirv_id         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Maybe Text
name             <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"name"
  Word32
location         <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"location"
  Maybe Word32
component        <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"component"
  StorageClass
storage_class    <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"storage_class" Parser Int32 -> (Int32 -> StorageClass) -> Parser StorageClass
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> StorageClass
SpirV.StorageClass
  Maybe Text
semantic         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"semantic"
  DecorationFlagBits
decoration_flags <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"decoration_flags" Parser Word32
-> (Word32 -> DecorationFlagBits) -> Parser DecorationFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Word32 -> DecorationFlagBits
Reflect.DecorationFlagBits
  Numeric
numeric          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"numeric" Parser (Node Pos) -> (Node Pos -> Parser Numeric) -> Parser Numeric
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Numeric
traitsNumericP
  Array
array            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  Vector InterfaceVariable
members          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"members" Parser (Maybe (Node Pos))
-> NodeParser (Maybe InterfaceVariable)
-> Parser (Vector InterfaceVariable)
forall a.
Parser (Maybe (Node Pos))
-> NodeParser (Maybe a) -> Parser (Vector a)
`seqOfMaybes` NodeParser (Maybe InterfaceVariable)
-> NodeParser (Maybe InterfaceVariable)
-> NodeParser (Maybe InterfaceVariable)
forall a. NodeParser a -> NodeParser a -> NodeParser a
alt ((InterfaceVariable -> Maybe InterfaceVariable)
-> Parser InterfaceVariable -> Parser (Maybe InterfaceVariable)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap InterfaceVariable -> Maybe InterfaceVariable
forall a. a -> Maybe a
Just (Parser InterfaceVariable -> Parser (Maybe InterfaceVariable))
-> NodeParser InterfaceVariable
-> NodeParser (Maybe InterfaceVariable)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NodeParser InterfaceVariable
interfaceVariableP) NodeParser (Maybe InterfaceVariable)
forall a. NodeParser (Maybe a)
recursiveP
  Maybe BuiltIn
built_in <-
    -- BUG: https://github.com/KhronosGroup/SPIRV-Reflect/issues/269
    if Vector InterfaceVariable -> Bool
forall a. Vector a -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null Vector InterfaceVariable
members then
      Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Int32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"built_in" Parser (Maybe Int32)
-> (Maybe Int32 -> Maybe BuiltIn) -> Parser (Maybe BuiltIn)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Int32 -> BuiltIn) -> Maybe Int32 -> Maybe BuiltIn
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int32 -> BuiltIn
SpirV.BuiltIn
    else
      Maybe BuiltIn -> Parser (Maybe BuiltIn)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe BuiltIn
forall a. Maybe a
Nothing
  Format
format           <- Mapping Pos
m Mapping Pos -> Text -> Parser Int
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"format" Parser Int -> (Int -> Format) -> Parser Format
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int -> Format
Reflect.Format
  Maybe TypeDescription
type_description <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  WordOffset
word_offset      <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"word_offset" Parser (Node Pos)
-> (Node Pos -> Parser WordOffset) -> Parser WordOffset
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser WordOffset
interfaceVariableWordOffsetP
  pure InterfaceVariable.InterfaceVariable{Maybe Word32
Maybe Text
Maybe BuiltIn
Maybe TypeDescription
Word32
StorageClass
DecorationFlagBits
Format
Array
Numeric
WordOffset
Vector InterfaceVariable
spirv_id :: Maybe Word32
name :: Maybe Text
location :: Word32
component :: Maybe Word32
storage_class :: StorageClass
semantic :: Maybe Text
decoration_flags :: DecorationFlagBits
numeric :: Numeric
array :: Array
members :: Vector InterfaceVariable
built_in :: Maybe BuiltIn
format :: Format
type_description :: Maybe TypeDescription
word_offset :: WordOffset
$sel:spirv_id:InterfaceVariable :: Maybe Word32
$sel:name:InterfaceVariable :: Maybe Text
$sel:location:InterfaceVariable :: Word32
$sel:component:InterfaceVariable :: Maybe Word32
$sel:storage_class:InterfaceVariable :: StorageClass
$sel:semantic:InterfaceVariable :: Maybe Text
$sel:decoration_flags:InterfaceVariable :: DecorationFlagBits
$sel:built_in:InterfaceVariable :: Maybe BuiltIn
$sel:numeric:InterfaceVariable :: Numeric
$sel:array:InterfaceVariable :: Array
$sel:members:InterfaceVariable :: Vector InterfaceVariable
$sel:format:InterfaceVariable :: Format
$sel:type_description:InterfaceVariable :: Maybe TypeDescription
$sel:word_offset:InterfaceVariable :: WordOffset
..}

interfaceVariableWordOffsetP :: NodeParser InterfaceVariable.WordOffset
interfaceVariableWordOffsetP :: Node Pos -> Parser WordOffset
interfaceVariableWordOffsetP = String
-> (Mapping Pos -> Parser WordOffset)
-> Node Pos
-> Parser WordOffset
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"InterfaceVariable.WordOffset" \Mapping Pos
m -> do
  Word32
location <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"location"
  pure InterfaceVariable.WordOffset{Word32
location :: Word32
$sel:location:WordOffset :: Word32
..}

blockVariableP :: NodeParser BlockVariable
blockVariableP :: NodeParser BlockVariable
blockVariableP = String
-> (Mapping Pos -> Parser BlockVariable)
-> NodeParser BlockVariable
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"BlockVariable" \Mapping Pos
m -> do
  Maybe Word32
spirv_id         <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Maybe Text
name             <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"name"
  Word32
offset           <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"offset"
  Word32
absolute_offset  <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"absolute_offset"
  Word32
size             <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"size"
  Word32
padded_size      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"padded_size"
  DecorationFlagBits
decorations      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"decorations" Parser Word32
-> (Word32 -> DecorationFlagBits) -> Parser DecorationFlagBits
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Word32 -> DecorationFlagBits
Reflect.DecorationFlagBits
  Numeric
numeric          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"numeric" Parser (Node Pos) -> (Node Pos -> Parser Numeric) -> Parser Numeric
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Numeric
traitsNumericP
  Array
array            <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"array" Parser (Node Pos) -> (Node Pos -> Parser Array) -> Parser Array
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Array
traitsArrayP
  Vector BlockVariable
members          <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"members" Parser (Maybe (Node Pos))
-> NodeParser (Maybe BlockVariable)
-> Parser (Vector BlockVariable)
forall a.
Parser (Maybe (Node Pos))
-> NodeParser (Maybe a) -> Parser (Vector a)
`seqOfMaybes` NodeParser (Maybe BlockVariable)
-> NodeParser (Maybe BlockVariable)
-> NodeParser (Maybe BlockVariable)
forall a. NodeParser a -> NodeParser a -> NodeParser a
alt NodeParser (Maybe BlockVariable)
forall a. NodeParser (Maybe a)
recursiveP ((BlockVariable -> Maybe BlockVariable)
-> Parser BlockVariable -> Parser (Maybe BlockVariable)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap BlockVariable -> Maybe BlockVariable
forall a. a -> Maybe a
Just (Parser BlockVariable -> Parser (Maybe BlockVariable))
-> NodeParser BlockVariable -> NodeParser (Maybe BlockVariable)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NodeParser BlockVariable
blockVariableP)
  Maybe TypeDescription
type_description <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"type_description" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe TypeDescription))
-> Parser (Maybe TypeDescription)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser TypeDescription)
-> Maybe (Node Pos) -> Parser (Maybe TypeDescription)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser TypeDescription
typeDescriptionP
  Maybe WordOffset
word_offset      <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe (Node Pos))
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"word_offset" Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Maybe WordOffset))
-> Parser (Maybe WordOffset)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Node Pos -> Parser WordOffset)
-> Maybe (Node Pos) -> Parser (Maybe WordOffset)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Maybe a -> f (Maybe b)
traverse Node Pos -> Parser WordOffset
blockVariableWordOffsetP
  pure BlockVariable.BlockVariable{Maybe Word32
Maybe Text
Maybe TypeDescription
Maybe WordOffset
Word32
DecorationFlagBits
Array
Numeric
Vector BlockVariable
spirv_id :: Maybe Word32
name :: Maybe Text
offset :: Word32
absolute_offset :: Word32
size :: Word32
padded_size :: Word32
decorations :: DecorationFlagBits
numeric :: Numeric
array :: Array
members :: Vector BlockVariable
type_description :: Maybe TypeDescription
word_offset :: Maybe WordOffset
$sel:spirv_id:BlockVariable :: Maybe Word32
$sel:name:BlockVariable :: Maybe Text
$sel:offset:BlockVariable :: Word32
$sel:absolute_offset:BlockVariable :: Word32
$sel:size:BlockVariable :: Word32
$sel:padded_size:BlockVariable :: Word32
$sel:decorations:BlockVariable :: DecorationFlagBits
$sel:numeric:BlockVariable :: Numeric
$sel:array:BlockVariable :: Array
$sel:members:BlockVariable :: Vector BlockVariable
$sel:type_description:BlockVariable :: Maybe TypeDescription
$sel:word_offset:BlockVariable :: Maybe WordOffset
..}

blockVariableWordOffsetP :: NodeParser BlockVariable.WordOffset
blockVariableWordOffsetP :: Node Pos -> Parser WordOffset
blockVariableWordOffsetP = String
-> (Mapping Pos -> Parser WordOffset)
-> Node Pos
-> Parser WordOffset
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"BlockVariable.WordOffset" \Mapping Pos
m -> do
  Word32
offset <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"offset"
  pure BlockVariable.WordOffset{Word32
offset :: Word32
$sel:offset:WordOffset :: Word32
..}

specializationConstantP :: NodeParser SpecializationConstant
specializationConstantP :: NodeParser SpecializationConstant
specializationConstantP = String
-> (Mapping Pos -> Parser SpecializationConstant)
-> NodeParser SpecializationConstant
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"SpecializationConstant" \Mapping Pos
m -> do
  Maybe Word32
spirv_id    <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"spirv_id"
  Word32
constant_id <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"constant_id"
  Maybe Text
name        <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Text)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"name"
  pure SpecializationConstant.SpecializationConstant{Maybe Word32
Maybe Text
Word32
spirv_id :: Maybe Word32
constant_id :: Word32
name :: Maybe Text
$sel:spirv_id:SpecializationConstant :: Maybe Word32
$sel:constant_id:SpecializationConstant :: Word32
$sel:name:SpecializationConstant :: Maybe Text
..}

--------------

traitsNumericP :: NodeParser Traits.Numeric
traitsNumericP :: Node Pos -> Parser Numeric
traitsNumericP = String
-> (Mapping Pos -> Parser Numeric) -> Node Pos -> Parser Numeric
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Numeric" \Mapping Pos
m -> do
  Scalar
scalar <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"scalar" Parser (Node Pos) -> (Node Pos -> Parser Scalar) -> Parser Scalar
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Scalar
traitsScalarP
  Vector
vector <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"vector" Parser (Node Pos) -> (Node Pos -> Parser Vector) -> Parser Vector
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Vector
traitsVectorP
  Matrix
matrix <- Mapping Pos
m Mapping Pos -> Text -> Parser (Node Pos)
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"matrix" Parser (Node Pos) -> (Node Pos -> Parser Matrix) -> Parser Matrix
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Node Pos -> Parser Matrix
traitsMatrixP
  pure Traits.Numeric{Matrix
Vector
Scalar
scalar :: Scalar
vector :: Vector
matrix :: Matrix
$sel:scalar:Numeric :: Scalar
$sel:vector:Numeric :: Vector
$sel:matrix:Numeric :: Matrix
..}

traitsScalarP :: NodeParser Traits.Scalar
traitsScalarP :: Node Pos -> Parser Scalar
traitsScalarP = String
-> (Mapping Pos -> Parser Scalar) -> Node Pos -> Parser Scalar
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Scalar" \Mapping Pos
m -> do
  Word32
width  <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"width"
  Bool
signed <- Mapping Pos
m Mapping Pos -> Text -> Parser Word
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"signedness" Parser Word -> (Word -> Bool) -> Parser Bool
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> (Word -> Word -> Bool
forall a. Eq a => a -> a -> Bool
/= (Word
0 :: Word))
  pure Traits.Scalar{Bool
Word32
width :: Word32
signed :: Bool
$sel:width:Scalar :: Word32
$sel:signed:Scalar :: Bool
..}

traitsVectorP :: NodeParser Traits.Vector
traitsVectorP :: Node Pos -> Parser Vector
traitsVectorP = String
-> (Mapping Pos -> Parser Vector) -> Node Pos -> Parser Vector
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Vector" \Mapping Pos
m -> do
  Word32
component_count <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"component_count"
  pure Traits.Vector{Word32
component_count :: Word32
$sel:component_count:Vector :: Word32
..}

traitsMatrixP :: NodeParser Traits.Matrix
traitsMatrixP :: Node Pos -> Parser Matrix
traitsMatrixP = String
-> (Mapping Pos -> Parser Matrix) -> Node Pos -> Parser Matrix
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Matrix" \Mapping Pos
m -> do
  Word32
column_count <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"column_count"
  Word32
row_count    <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"row_count"
  Word32
stride       <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"stride"
  pure Traits.Matrix{Word32
column_count :: Word32
row_count :: Word32
stride :: Word32
$sel:column_count:Matrix :: Word32
$sel:row_count:Matrix :: Word32
$sel:stride:Matrix :: Word32
..}

traitsArrayP :: NodeParser Traits.Array
traitsArrayP :: Node Pos -> Parser Array
traitsArrayP = String -> (Mapping Pos -> Parser Array) -> Node Pos -> Parser Array
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Array" \Mapping Pos
m -> do
  Word32
dims_count <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"dims_count"
  Vector Word32
dims       <- Mapping Pos
m Mapping Pos -> Text -> Parser [Word32]
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"dims" Parser [Word32]
-> ([Word32] -> Vector Word32) -> Parser (Vector Word32)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> [Word32] -> Vector Word32
forall a. Storable a => [a] -> Vector a
Storable.fromList
  Maybe Word32
stride     <- Mapping Pos
m Mapping Pos -> Text -> Parser (Maybe Word32)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
"stride" Parser (Maybe Word32)
-> (Maybe Word32 -> Maybe Word32) -> Parser (Maybe Word32)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe Word32
stride -> if Maybe Word32
stride Maybe Word32 -> Maybe Word32 -> Bool
forall a. Eq a => a -> a -> Bool
== Word32 -> Maybe Word32
forall a. a -> Maybe a
Just Word32
0 then Maybe Word32
forall a. Maybe a
Nothing else Maybe Word32
stride
  pure Traits.Array{Maybe Word32
Word32
Vector Word32
dims_count :: Word32
dims :: Vector Word32
stride :: Maybe Word32
$sel:dims_count:Array :: Word32
$sel:dims:Array :: Vector Word32
$sel:stride:Array :: Maybe Word32
..}

traitsImageP :: NodeParser Traits.Image
traitsImageP :: Node Pos -> Parser Image
traitsImageP = String -> (Mapping Pos -> Parser Image) -> Node Pos -> Parser Image
forall a.
String -> (Mapping Pos -> Parser a) -> Node Pos -> Parser a
YAML.withMap String
"Image" \Mapping Pos
m -> do
  Dim
dim          <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"dim" Parser Int32 -> (Int32 -> Dim) -> Parser Dim
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> Dim
SpirV.Dim
  Word32
depth        <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"depth"
  Word32
arrayed      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"arrayed"
  Word32
ms           <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"ms"
  Word32
sampled      <- Mapping Pos
m Mapping Pos -> Text -> Parser Word32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"sampled"
  ImageFormat
image_format <- Mapping Pos
m Mapping Pos -> Text -> Parser Int32
forall a. FromYAML a => Mapping Pos -> Text -> Parser a
.: Text
"image_format" Parser Int32 -> (Int32 -> ImageFormat) -> Parser ImageFormat
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> Int32 -> ImageFormat
SpirV.ImageFormat
  pure Traits.Image{Word32
Dim
ImageFormat
dim :: Dim
depth :: Word32
arrayed :: Word32
ms :: Word32
sampled :: Word32
image_format :: ImageFormat
$sel:dim:Image :: Dim
$sel:depth:Image :: Word32
$sel:arrayed:Image :: Word32
$sel:ms:Image :: Word32
$sel:sampled:Image :: Word32
$sel:image_format:Image :: ImageFormat
..}

recursiveP :: NodeParser (Maybe a)
recursiveP :: forall a. NodeParser (Maybe a)
recursiveP = \case
  YAML.Sequence Pos
_pos Tag
_tag [YAML.Scalar Pos
_pos2 (YAML.SStr Text
"recursive")] -> Maybe a -> Parser (Maybe a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
  Node Pos
_ -> String -> Parser (Maybe a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Unexpected token"

forwardPointerP :: NodeParser (Maybe a)
forwardPointerP :: forall a. NodeParser (Maybe a)
forwardPointerP = \case
  YAML.Sequence Pos
_pos Tag
_tag [YAML.Scalar Pos
_pos2 (YAML.SStr Text
"forward pointer")] -> Maybe a -> Parser (Maybe a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe a
forall a. Maybe a
Nothing
  Node Pos
_ -> String -> Parser (Maybe a)
forall a. String -> Parser a
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"Unexpected token"

type NodeParser a =
  YAML.Node YAML.Pos ->
  YAML.Parser a

alt :: NodeParser a -> NodeParser a -> NodeParser a
alt :: forall a. NodeParser a -> NodeParser a -> NodeParser a
alt NodeParser a
a NodeParser a
b Node Pos
n = NodeParser a
a Node Pos
n Parser a -> Parser a -> Parser a
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> NodeParser a
b Node Pos
n

(.?)
  :: YAML.FromYAML a
  => YAML.Mapping YAML.Pos
  -> Text
  -> YAML.Parser (Maybe a)
Mapping Pos
o .? :: forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
.? Text
v = Mapping Pos
o Mapping Pos -> Text -> Parser (Maybe a)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
YAML..:? Text
v

(.|)
  :: (YAML.FromYAML a, Monoid a)
  => YAML.Mapping YAML.Pos
  -> Text
  -> YAML.Parser a
Mapping Pos
o .| :: forall a. (FromYAML a, Monoid a) => Mapping Pos -> Text -> Parser a
.| Text
v = Mapping Pos
o Mapping Pos -> Text -> Parser (Maybe a)
forall a. FromYAML a => Mapping Pos -> Text -> Parser (Maybe a)
YAML..:? Text
v Parser (Maybe a) -> a -> Parser a
forall a. Parser (Maybe a) -> a -> Parser a
YAML..!= a
forall a. Monoid a => a
mempty

seqOf
  :: YAML.Parser (Maybe (YAML.Node YAML.Pos))
  -> NodeParser a
  -> YAML.Parser (Vector a)
seqOf :: forall a.
Parser (Maybe (Node Pos)) -> NodeParser a -> Parser (Vector a)
seqOf Parser (Maybe (Node Pos))
mappingP NodeParser a
nodeP =
  Parser (Maybe (Node Pos))
mappingP Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Vector a)) -> Parser (Vector a)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Maybe (Node Pos)
Nothing ->
      Vector a -> Parser (Vector a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
forall a. Monoid a => a
mempty
    Just Node Pos
items ->
      String
-> ([Node Pos] -> Parser (Vector a))
-> Node Pos
-> Parser (Vector a)
forall a.
String -> ([Node Pos] -> Parser a) -> Node Pos -> Parser a
YAML.withSeq String
"seqOf" (([a] -> Vector a) -> Parser [a] -> Parser (Vector a)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [a] -> Vector a
forall a. [a] -> Vector a
Vector.fromList (Parser [a] -> Parser (Vector a))
-> ([Node Pos] -> Parser [a]) -> [Node Pos] -> Parser (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NodeParser a -> [Node Pos] -> Parser [a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse NodeParser a
nodeP) Node Pos
items

seqOfMaybes
  :: YAML.Parser (Maybe (YAML.Node YAML.Pos))
  -> NodeParser (Maybe a)
  -> YAML.Parser (Vector a)
seqOfMaybes :: forall a.
Parser (Maybe (Node Pos))
-> NodeParser (Maybe a) -> Parser (Vector a)
seqOfMaybes Parser (Maybe (Node Pos))
mappingP NodeParser (Maybe a)
nodeP =
  Parser (Maybe (Node Pos))
mappingP Parser (Maybe (Node Pos))
-> (Maybe (Node Pos) -> Parser (Vector a)) -> Parser (Vector a)
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
    Maybe (Node Pos)
Nothing ->
      Vector a -> Parser (Vector a)
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Vector a
forall a. Monoid a => a
mempty
    Just Node Pos
items ->
      String
-> ([Node Pos] -> Parser (Vector a))
-> Node Pos
-> Parser (Vector a)
forall a.
String -> ([Node Pos] -> Parser a) -> Node Pos -> Parser a
YAML.withSeq String
"seqOf" (([Maybe a] -> Vector a) -> Parser [Maybe a] -> Parser (Vector a)
forall a b. (a -> b) -> Parser a -> Parser b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([a] -> Vector a
forall a. [a] -> Vector a
Vector.fromList ([a] -> Vector a) -> ([Maybe a] -> [a]) -> [Maybe a] -> Vector a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Maybe a] -> [a]
forall a. [Maybe a] -> [a]
catMaybes) (Parser [Maybe a] -> Parser (Vector a))
-> ([Node Pos] -> Parser [Maybe a])
-> [Node Pos]
-> Parser (Vector a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NodeParser (Maybe a) -> [Node Pos] -> Parser [Maybe a]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse NodeParser (Maybe a)
nodeP) Node Pos
items