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

newtype Identifier Source

Constructors

Identifier
Fields unIdentifier :: String

Instances

Eq Identifier
Ord Identifier
Show Identifier
IsString Identifier
Pretty Identifier
Typeable * Identifier

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 Source

Constructors

VariablySized
Unsized
SizedByInteger Integer
SizedByIdentifier Identifier

Instances

Eq ArrayType
Show ArrayType
Pretty ArrayType
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 Source

Constructors

TypeSpecifier Specifiers TypeSpecifier
Ptr [TypeQualifier] Type
Array ArrayType Type
Proto Type [ParameterDeclaration]

Instances

Eq Type
Show Type
Pretty Type
Typeable * Type

data TypeSpecifier Source

Constructors

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

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 Source

Constructors

ParameterDeclaration
Fields parameterDeclarationId :: Maybe Identifier parameterDeclarationType :: Type

Instances

Eq ParameterDeclaration
Show ParameterDeclaration
Pretty ParameterDeclaration
Typeable * ParameterDeclaration

Parsing

type IsTypeName = Identifier -> Bool Source

Function used to determine whether an Id is a type name.

type CParser m = (Monad m, Functor m, Applicative m, MonadPlus m, Parsing m, CharParsing m, TokenParsing m, LookAheadParsing m, MonadReader IsTypeName m) 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.

The MonadReader with IsTypeName is required for parsing C, see http://en.wikipedia.org/wiki/The_lexer_hack.

runCParser Source

Arguments

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

Runs a CParser using parsec.

quickCParser Source

Arguments

:: IsTypeName	Function determining if an identifier is a type name.
-> String	String to parse.
-> ReaderT IsTypeName (Parsec String ()) a	Parser. Anything with type `forall m. CParser 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 IsTypeName (Parsec String ()) a	Parser. Anything with type `forall m. CParser m => m a` is a valid argument.
-> a

Like quickCParser, but uses const False as IsTypeName.

parseParameterDeclaration :: CParser m => m ParameterDeclaration Source

parseParameterList :: CParser m => m [ParameterDeclaration] Source

parseIdentifier :: CParser m => m Identifier Source

parseType :: CParser m => m Type 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 -> Either UntangleErr ParameterDeclaration Source

tangleParameterDeclaration :: ParameterDeclaration -> ParameterDeclaration Source

To english

describeParameterDeclaration :: ParameterDeclaration -> Doc Source

describeType :: Type -> Doc Source