Safe Haskell	None
Language	Haskell2010

Language.C.Types

Contents

Types
Parsing
Convert to and from high-level views
To english

Description

Views of C datatypes. While Language.C.Types.Parse defines datatypes for representing the concrete syntax tree of C types, this module provides friendlier views of C types, by turning them into a data type matching more closely how we read and think about types, both in Haskell and in C. To appreciate the difference, look at the difference between ParameterDeclaration and ParameterDeclaration.

As a bonus, routines are provided for describing types in natural language (English) -- see describeParameterDeclaration and describeType.

Synopsis

Types

data CIdentifier Source

A type for C identifiers.

Instances

Eq CIdentifier
Ord CIdentifier
Show CIdentifier
IsString CIdentifier
Arbitrary CIdentifier
Pretty CIdentifier
Hashable CIdentifier
Typeable * CIdentifier

unCIdentifier :: CIdentifier -> String Source

cIdentifierFromString :: String -> Either String CIdentifier Source

data StorageClassSpecifier Source

Constructors

TYPEDEF
EXTERN
STATIC
AUTO
REGISTER

Instances

Eq StorageClassSpecifier
Show StorageClassSpecifier
Arbitrary StorageClassSpecifier
Pretty StorageClassSpecifier
Typeable * StorageClassSpecifier

data TypeQualifier Source

Constructors

CONST
RESTRICT
VOLATILE

Instances

Eq TypeQualifier
Show TypeQualifier
Arbitrary TypeQualifier
Pretty TypeQualifier
Typeable * TypeQualifier

data FunctionSpecifier Source

Constructors

INLINE

Instances

Eq FunctionSpecifier
Show FunctionSpecifier
Arbitrary FunctionSpecifier
Pretty FunctionSpecifier
Typeable * FunctionSpecifier

data ArrayType i Source

Constructors

VariablySized
Unsized
SizedByInteger Integer
SizedByIdentifier i

Instances

Functor ArrayType
Foldable ArrayType
Traversable ArrayType
Eq i => Eq (ArrayType i)
Show i => Show (ArrayType i)
Pretty i => Pretty (ArrayType i)
Typeable (* -> *) ArrayType

data Specifiers Source

Constructors

Specifiers
Fields storageClassSpecifiers :: [StorageClassSpecifier] typeQualifiers :: [TypeQualifier] functionSpecifiers :: [FunctionSpecifier]

Instances

Eq Specifiers
Show Specifiers
Monoid Specifiers
Typeable * Specifiers

data Type i Source

Constructors

TypeSpecifier Specifiers TypeSpecifier
Ptr [TypeQualifier] (Type i)
Array (ArrayType i) (Type i)
Proto (Type i) [ParameterDeclaration i]

Instances

Functor Type
Foldable Type
Traversable Type
Eq i => Eq (Type i)
Show i => Show (Type i)
Pretty i => Pretty (Type i)
Typeable (* -> *) Type

data TypeSpecifier Source

Constructors

Void
Char (Maybe Sign)
Short Sign
Int Sign
Long Sign
LLong Sign
Float
Double
LDouble
TypeName CIdentifier
Struct CIdentifier
Enum CIdentifier

Instances

Eq TypeSpecifier
Ord TypeSpecifier
Show TypeSpecifier
Pretty TypeSpecifier
Typeable * TypeSpecifier

data Sign Source

Constructors

Signed
Unsigned

Instances

Eq Sign
Ord Sign
Show Sign
Typeable * Sign

data ParameterDeclaration i Source

Constructors

ParameterDeclaration
Fields parameterDeclarationId :: Maybe i parameterDeclarationType :: Type i

Instances

Functor ParameterDeclaration
Foldable ParameterDeclaration
Traversable ParameterDeclaration
Eq i => Eq (ParameterDeclaration i)
Show i => Show (ParameterDeclaration i)
Pretty i => Pretty (ParameterDeclaration i)
Typeable (* -> *) ParameterDeclaration

Parsing

type TypeNames = HashSet CIdentifier Source

A collection of named types (typedefs)

type CParser i m = (Monad m, Functor m, Applicative m, MonadPlus m, Parsing m, CharParsing m, TokenParsing m, LookAheadParsing m, MonadReader (CParserContext i) m, Hashable i) Source

All the parsing is done using the type classes provided by the parsers package. You can use the parsing routines with any of the parsers that implement the classes, such as parsec or trifecta.

We parametrize the parsing by the type of the variable identifiers, i. We do so because we use this parser to implement anti-quoters referring to Haskell variables, and thus we need to parse Haskell identifiers in certain positions.

data CParserContext i Source

cCParserContext :: TypeNames -> CParserContext CIdentifier Source

runCParser Source

Arguments

:: Stream s Identity Char
=> CParserContext i
-> String	Source name.
-> s	String to parse.
-> ReaderT (CParserContext i) (Parsec s ()) a	Parser. Anything with type `forall m. CParser i m => m a` is a valid argument.
-> Either ParseError a

Runs a CParser using parsec.

quickCParser Source

Arguments

:: CParserContext i
-> String	String to parse.
-> ReaderT (CParserContext i) (Parsec String ()) a	Parser. Anything with type `forall m. CParser i m => m a` is a valid argument.
-> a

Useful for quick testing. Uses "quickCParser" as source name, and throws an error if parsing fails.

quickCParser_ Source

Arguments

:: String	String to parse.
-> ReaderT (CParserContext CIdentifier) (Parsec String ()) a	Parser. Anything with type `forall m. CParser i m => m a` is a valid argument.
-> a

Like quickCParser, but uses cCParserContext (const False) as CParserContext.

parseParameterDeclaration :: (CParser i m, Pretty i) => m (ParameterDeclaration i) Source

parseParameterList :: (CParser i m, Pretty i) => m [ParameterDeclaration i] Source

parseIdentifier :: CParser i m => m i Source

parseType :: (CParser i m, Pretty i) => m (Type i) Source

Convert to and from high-level views

data UntangleErr Source

Constructors

MultipleDataTypes [DeclarationSpecifier]
NoDataTypes [DeclarationSpecifier]
IllegalSpecifiers String [TypeSpecifier]

Instances

Eq UntangleErr
Show UntangleErr
Pretty UntangleErr
Typeable * UntangleErr

untangleParameterDeclaration :: ParameterDeclaration i -> Either UntangleErr (ParameterDeclaration i) Source

tangleParameterDeclaration :: forall i. ParameterDeclaration i -> ParameterDeclaration i Source

To english

describeParameterDeclaration :: Pretty i => ParameterDeclaration i -> Doc Source

describeType :: Pretty i => Type i -> Doc Source