Language.C.Types.Parse

A parser for C99 declarations. Currently, the parser has the following limitations:

• Array sizes can only be *, n (where n is a positive integer), x (where x is a C identifier). In C99 they can be arbitrary expressions. See the ArrayType data type.
• _Bool, _Complex, and _Imaginary are not present.
• Untyped parameter lists (pre-K&R C) are not allowed.

The parser is incremental and generic (see CParser). Pretty and Arbitrary instances are provided for all the data types.

The entry point if you want to parse C declarations is parameter_declaration.

Parser configuration

type TypeNames = HashSet CIdentifier

A collection of named types (typedefs)

data CParserContext i

Constructors

CParserContext

Fields

• cpcIdentName :: String
• cpcTypeNames :: TypeNames

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

• cpcParseIdent :: forall m. CParser i m => m i

  Parses an identifier, *without consuming whitespace afterwards*.

• cpcIdentToString :: i -> String

Default configuration

data CIdentifier

A type for C identifiers.

Instances

Eq CIdentifier

Defined in Language.C.Types.Parse

Methods

(==) :: CIdentifier -> CIdentifier -> Bool

(/=) :: CIdentifier -> CIdentifier -> Bool

Ord CIdentifier

Defined in Language.C.Types.Parse

Methods

compare :: CIdentifier -> CIdentifier -> Ordering

(<) :: CIdentifier -> CIdentifier -> Bool

(<=) :: CIdentifier -> CIdentifier -> Bool

(>) :: CIdentifier -> CIdentifier -> Bool

(>=) :: CIdentifier -> CIdentifier -> Bool

max :: CIdentifier -> CIdentifier -> CIdentifier

min :: CIdentifier -> CIdentifier -> CIdentifier

Show CIdentifier

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> CIdentifier -> ShowS

show :: CIdentifier -> String

showList :: [CIdentifier] -> ShowS

IsString CIdentifier

Defined in Language.C.Types.Parse

Methods

fromString :: String -> CIdentifier

Pretty CIdentifier

Defined in Language.C.Types.Parse

Methods

pretty :: CIdentifier -> Doc

prettyList :: [CIdentifier] -> Doc

Hashable CIdentifier

Defined in Language.C.Types.Parse

Methods

hashWithSalt :: Int -> CIdentifier -> Int

hash :: CIdentifier -> Int

unCIdentifier :: CIdentifier -> String

cIdentifierFromString :: String -> Either String CIdentifier

cCParserContext :: TypeNames -> CParserContext CIdentifier

Parser type

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)

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.

runCParser

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

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_

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.

Types and parsing

identifier_no_lex :: CParser i m => m i

data DeclarationSpecifier

Constructors

StorageClassSpecifier StorageClassSpecifier

TypeSpecifier TypeSpecifier

TypeQualifier TypeQualifier

FunctionSpecifier FunctionSpecifier

Instances

Eq DeclarationSpecifier

Defined in Language.C.Types.Parse

Methods

(==) :: DeclarationSpecifier -> DeclarationSpecifier -> Bool

(/=) :: DeclarationSpecifier -> DeclarationSpecifier -> Bool

Show DeclarationSpecifier

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> DeclarationSpecifier -> ShowS

show :: DeclarationSpecifier -> String

showList :: [DeclarationSpecifier] -> ShowS

Pretty DeclarationSpecifier

Defined in Language.C.Types.Parse

Methods

pretty :: DeclarationSpecifier -> Doc

prettyList :: [DeclarationSpecifier] -> Doc

declaration_specifiers :: CParser i m => m [DeclarationSpecifier]

data StorageClassSpecifier

Constructors

TYPEDEF

EXTERN

STATIC

AUTO

REGISTER

Instances

Eq StorageClassSpecifier

Defined in Language.C.Types.Parse

Methods

(==) :: StorageClassSpecifier -> StorageClassSpecifier -> Bool

(/=) :: StorageClassSpecifier -> StorageClassSpecifier -> Bool

Show StorageClassSpecifier

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> StorageClassSpecifier -> ShowS

show :: StorageClassSpecifier -> String

showList :: [StorageClassSpecifier] -> ShowS

Pretty StorageClassSpecifier

Defined in Language.C.Types.Parse

Methods

pretty :: StorageClassSpecifier -> Doc

prettyList :: [StorageClassSpecifier] -> Doc

storage_class_specifier :: CParser i m => m StorageClassSpecifier

data TypeSpecifier

Constructors

VOID

CHAR

SHORT

INT

LONG

FLOAT

DOUBLE

SIGNED

UNSIGNED

Struct CIdentifier

Enum CIdentifier

TypeName CIdentifier

Instances

Eq TypeSpecifier

Defined in Language.C.Types.Parse

Methods

(==) :: TypeSpecifier -> TypeSpecifier -> Bool

(/=) :: TypeSpecifier -> TypeSpecifier -> Bool

Show TypeSpecifier

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> TypeSpecifier -> ShowS

show :: TypeSpecifier -> String

showList :: [TypeSpecifier] -> ShowS

Pretty TypeSpecifier

Defined in Language.C.Types.Parse

Methods

pretty :: TypeSpecifier -> Doc

prettyList :: [TypeSpecifier] -> Doc

type_specifier :: CParser i m => m TypeSpecifier

data TypeQualifier

Constructors

CONST

RESTRICT

VOLATILE

Instances

Eq TypeQualifier

Defined in Language.C.Types.Parse

Methods

(==) :: TypeQualifier -> TypeQualifier -> Bool

(/=) :: TypeQualifier -> TypeQualifier -> Bool

Show TypeQualifier

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> TypeQualifier -> ShowS

show :: TypeQualifier -> String

showList :: [TypeQualifier] -> ShowS

Pretty TypeQualifier

Defined in Language.C.Types.Parse

Methods

pretty :: TypeQualifier -> Doc

prettyList :: [TypeQualifier] -> Doc

type_qualifier :: CParser i m => m TypeQualifier

data FunctionSpecifier

Constructors

INLINE

Instances

Eq FunctionSpecifier

Defined in Language.C.Types.Parse

Methods

(==) :: FunctionSpecifier -> FunctionSpecifier -> Bool

(/=) :: FunctionSpecifier -> FunctionSpecifier -> Bool

Show FunctionSpecifier

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> FunctionSpecifier -> ShowS

show :: FunctionSpecifier -> String

showList :: [FunctionSpecifier] -> ShowS

Pretty FunctionSpecifier

Defined in Language.C.Types.Parse

Methods

pretty :: FunctionSpecifier -> Doc

prettyList :: [FunctionSpecifier] -> Doc

function_specifier :: CParser i m => m FunctionSpecifier

data Declarator i

Constructors

Declarator

Fields

• declaratorPointers :: [Pointer]
• declaratorDirect :: DirectDeclarator i

Instances

Functor Declarator

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> Declarator a -> Declarator b

(<$) :: a -> Declarator b -> Declarator a

Foldable Declarator

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => Declarator m -> m

foldMap :: Monoid m => (a -> m) -> Declarator a -> m

foldr :: (a -> b -> b) -> b -> Declarator a -> b

foldr' :: (a -> b -> b) -> b -> Declarator a -> b

foldl :: (b -> a -> b) -> b -> Declarator a -> b

foldl' :: (b -> a -> b) -> b -> Declarator a -> b

foldr1 :: (a -> a -> a) -> Declarator a -> a

foldl1 :: (a -> a -> a) -> Declarator a -> a

toList :: Declarator a -> [a]

null :: Declarator a -> Bool

length :: Declarator a -> Int

elem :: Eq a => a -> Declarator a -> Bool

maximum :: Ord a => Declarator a -> a

minimum :: Ord a => Declarator a -> a

sum :: Num a => Declarator a -> a

product :: Num a => Declarator a -> a

Traversable Declarator

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> Declarator a -> f (Declarator b)

sequenceA :: Applicative f => Declarator (f a) -> f (Declarator a)

mapM :: Monad m => (a -> m b) -> Declarator a -> m (Declarator b)

sequence :: Monad m => Declarator (m a) -> m (Declarator a)

Eq i => Eq (Declarator i)

Defined in Language.C.Types.Parse

Methods

(==) :: Declarator i -> Declarator i -> Bool

(/=) :: Declarator i -> Declarator i -> Bool

Show i => Show (Declarator i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> Declarator i -> ShowS

show :: Declarator i -> String

showList :: [Declarator i] -> ShowS

Pretty i => Pretty (Declarator i)

Defined in Language.C.Types.Parse

Methods

pretty :: Declarator i -> Doc

prettyList :: [Declarator i] -> Doc

declarator :: CParser i m => m (Declarator i)

data DirectDeclarator i

Constructors

DeclaratorRoot i

ArrayOrProto (DirectDeclarator i) (ArrayOrProto i)

DeclaratorParens (Declarator i)

Instances

Functor DirectDeclarator

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> DirectDeclarator a -> DirectDeclarator b

(<$) :: a -> DirectDeclarator b -> DirectDeclarator a

Foldable DirectDeclarator

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => DirectDeclarator m -> m

foldMap :: Monoid m => (a -> m) -> DirectDeclarator a -> m

foldr :: (a -> b -> b) -> b -> DirectDeclarator a -> b

foldr' :: (a -> b -> b) -> b -> DirectDeclarator a -> b

foldl :: (b -> a -> b) -> b -> DirectDeclarator a -> b

foldl' :: (b -> a -> b) -> b -> DirectDeclarator a -> b

foldr1 :: (a -> a -> a) -> DirectDeclarator a -> a

foldl1 :: (a -> a -> a) -> DirectDeclarator a -> a

toList :: DirectDeclarator a -> [a]

null :: DirectDeclarator a -> Bool

length :: DirectDeclarator a -> Int

elem :: Eq a => a -> DirectDeclarator a -> Bool

maximum :: Ord a => DirectDeclarator a -> a

minimum :: Ord a => DirectDeclarator a -> a

sum :: Num a => DirectDeclarator a -> a

product :: Num a => DirectDeclarator a -> a

Traversable DirectDeclarator

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> DirectDeclarator a -> f (DirectDeclarator b)

sequenceA :: Applicative f => DirectDeclarator (f a) -> f (DirectDeclarator a)

mapM :: Monad m => (a -> m b) -> DirectDeclarator a -> m (DirectDeclarator b)

sequence :: Monad m => DirectDeclarator (m a) -> m (DirectDeclarator a)

Eq i => Eq (DirectDeclarator i)

Defined in Language.C.Types.Parse

Methods

(==) :: DirectDeclarator i -> DirectDeclarator i -> Bool

(/=) :: DirectDeclarator i -> DirectDeclarator i -> Bool

Show i => Show (DirectDeclarator i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> DirectDeclarator i -> ShowS

show :: DirectDeclarator i -> String

showList :: [DirectDeclarator i] -> ShowS

Pretty i => Pretty (DirectDeclarator i)

Defined in Language.C.Types.Parse

Methods

pretty :: DirectDeclarator i -> Doc

prettyList :: [DirectDeclarator i] -> Doc

direct_declarator :: CParser i m => m (DirectDeclarator i)

data ArrayOrProto i

Constructors

Array (ArrayType i)

Proto [ParameterDeclaration i]

Instances

Functor ArrayOrProto

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> ArrayOrProto a -> ArrayOrProto b

(<$) :: a -> ArrayOrProto b -> ArrayOrProto a

Foldable ArrayOrProto

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => ArrayOrProto m -> m

foldMap :: Monoid m => (a -> m) -> ArrayOrProto a -> m

foldr :: (a -> b -> b) -> b -> ArrayOrProto a -> b

foldr' :: (a -> b -> b) -> b -> ArrayOrProto a -> b

foldl :: (b -> a -> b) -> b -> ArrayOrProto a -> b

foldl' :: (b -> a -> b) -> b -> ArrayOrProto a -> b

foldr1 :: (a -> a -> a) -> ArrayOrProto a -> a

foldl1 :: (a -> a -> a) -> ArrayOrProto a -> a

toList :: ArrayOrProto a -> [a]

null :: ArrayOrProto a -> Bool

length :: ArrayOrProto a -> Int

elem :: Eq a => a -> ArrayOrProto a -> Bool

maximum :: Ord a => ArrayOrProto a -> a

minimum :: Ord a => ArrayOrProto a -> a

sum :: Num a => ArrayOrProto a -> a

product :: Num a => ArrayOrProto a -> a

Traversable ArrayOrProto

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> ArrayOrProto a -> f (ArrayOrProto b)

sequenceA :: Applicative f => ArrayOrProto (f a) -> f (ArrayOrProto a)

mapM :: Monad m => (a -> m b) -> ArrayOrProto a -> m (ArrayOrProto b)

sequence :: Monad m => ArrayOrProto (m a) -> m (ArrayOrProto a)

Eq i => Eq (ArrayOrProto i)

Defined in Language.C.Types.Parse

Methods

(==) :: ArrayOrProto i -> ArrayOrProto i -> Bool

(/=) :: ArrayOrProto i -> ArrayOrProto i -> Bool

Show i => Show (ArrayOrProto i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> ArrayOrProto i -> ShowS

show :: ArrayOrProto i -> String

showList :: [ArrayOrProto i] -> ShowS

Pretty i => Pretty (ArrayOrProto i)

Defined in Language.C.Types.Parse

Methods

pretty :: ArrayOrProto i -> Doc

prettyList :: [ArrayOrProto i] -> Doc

array_or_proto :: CParser i m => m (ArrayOrProto i)

data ArrayType i

Constructors

VariablySized

Unsized

SizedByInteger Integer

SizedByIdentifier i

Instances

Functor ArrayType

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> ArrayType a -> ArrayType b

(<$) :: a -> ArrayType b -> ArrayType a

Foldable ArrayType

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => ArrayType m -> m

foldMap :: Monoid m => (a -> m) -> ArrayType a -> m

foldr :: (a -> b -> b) -> b -> ArrayType a -> b

foldr' :: (a -> b -> b) -> b -> ArrayType a -> b

foldl :: (b -> a -> b) -> b -> ArrayType a -> b

foldl' :: (b -> a -> b) -> b -> ArrayType a -> b

foldr1 :: (a -> a -> a) -> ArrayType a -> a

foldl1 :: (a -> a -> a) -> ArrayType a -> a

toList :: ArrayType a -> [a]

null :: ArrayType a -> Bool

length :: ArrayType a -> Int

elem :: Eq a => a -> ArrayType a -> Bool

maximum :: Ord a => ArrayType a -> a

minimum :: Ord a => ArrayType a -> a

sum :: Num a => ArrayType a -> a

product :: Num a => ArrayType a -> a

Traversable ArrayType

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> ArrayType a -> f (ArrayType b)

sequenceA :: Applicative f => ArrayType (f a) -> f (ArrayType a)

mapM :: Monad m => (a -> m b) -> ArrayType a -> m (ArrayType b)

sequence :: Monad m => ArrayType (m a) -> m (ArrayType a)

Eq i => Eq (ArrayType i)

Defined in Language.C.Types.Parse

Methods

(==) :: ArrayType i -> ArrayType i -> Bool

(/=) :: ArrayType i -> ArrayType i -> Bool

Show i => Show (ArrayType i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> ArrayType i -> ShowS

show :: ArrayType i -> String

showList :: [ArrayType i] -> ShowS

Pretty i => Pretty (ArrayType i)

Defined in Language.C.Types.Parse

Methods

pretty :: ArrayType i -> Doc

prettyList :: [ArrayType i] -> Doc

array_type :: CParser i m => m (ArrayType i)

data Pointer

Constructors

Pointer [TypeQualifier]

Instances

Eq Pointer

Defined in Language.C.Types.Parse

Methods

(==) :: Pointer -> Pointer -> Bool

(/=) :: Pointer -> Pointer -> Bool

Show Pointer

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> Pointer -> ShowS

show :: Pointer -> String

showList :: [Pointer] -> ShowS

Pretty Pointer

Defined in Language.C.Types.Parse

Methods

pretty :: Pointer -> Doc

prettyList :: [Pointer] -> Doc

pointer :: CParser i m => m Pointer

data ParameterDeclaration i

Constructors

ParameterDeclaration

Fields

• parameterDeclarationSpecifiers :: [DeclarationSpecifier]
• parameterDeclarationDeclarator :: DeclaratorOrAbstractDeclarator i

Instances

Functor ParameterDeclaration

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> ParameterDeclaration a -> ParameterDeclaration b

(<$) :: a -> ParameterDeclaration b -> ParameterDeclaration a

Foldable ParameterDeclaration

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => ParameterDeclaration m -> m

foldMap :: Monoid m => (a -> m) -> ParameterDeclaration a -> m

foldr :: (a -> b -> b) -> b -> ParameterDeclaration a -> b

foldr' :: (a -> b -> b) -> b -> ParameterDeclaration a -> b

foldl :: (b -> a -> b) -> b -> ParameterDeclaration a -> b

foldl' :: (b -> a -> b) -> b -> ParameterDeclaration a -> b

foldr1 :: (a -> a -> a) -> ParameterDeclaration a -> a

foldl1 :: (a -> a -> a) -> ParameterDeclaration a -> a

toList :: ParameterDeclaration a -> [a]

null :: ParameterDeclaration a -> Bool

length :: ParameterDeclaration a -> Int

elem :: Eq a => a -> ParameterDeclaration a -> Bool

maximum :: Ord a => ParameterDeclaration a -> a

minimum :: Ord a => ParameterDeclaration a -> a

sum :: Num a => ParameterDeclaration a -> a

product :: Num a => ParameterDeclaration a -> a

Traversable ParameterDeclaration

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> ParameterDeclaration a -> f (ParameterDeclaration b)

sequenceA :: Applicative f => ParameterDeclaration (f a) -> f (ParameterDeclaration a)

mapM :: Monad m => (a -> m b) -> ParameterDeclaration a -> m (ParameterDeclaration b)

sequence :: Monad m => ParameterDeclaration (m a) -> m (ParameterDeclaration a)

Eq i => Eq (ParameterDeclaration i)

Defined in Language.C.Types.Parse

Methods

(==) :: ParameterDeclaration i -> ParameterDeclaration i -> Bool

(/=) :: ParameterDeclaration i -> ParameterDeclaration i -> Bool

Show i => Show (ParameterDeclaration i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> ParameterDeclaration i -> ShowS

show :: ParameterDeclaration i -> String

showList :: [ParameterDeclaration i] -> ShowS

Pretty i => Pretty (ParameterDeclaration i)

Defined in Language.C.Types.Parse

Methods

pretty :: ParameterDeclaration i -> Doc

prettyList :: [ParameterDeclaration i] -> Doc

data DeclaratorOrAbstractDeclarator i

Constructors

IsDeclarator (Declarator i)

IsAbstractDeclarator (AbstractDeclarator i)

Instances

Functor DeclaratorOrAbstractDeclarator

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> DeclaratorOrAbstractDeclarator a -> DeclaratorOrAbstractDeclarator b

(<$) :: a -> DeclaratorOrAbstractDeclarator b -> DeclaratorOrAbstractDeclarator a

Foldable DeclaratorOrAbstractDeclarator

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => DeclaratorOrAbstractDeclarator m -> m

foldMap :: Monoid m => (a -> m) -> DeclaratorOrAbstractDeclarator a -> m

foldr :: (a -> b -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b

foldr' :: (a -> b -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b

foldl :: (b -> a -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b

foldl' :: (b -> a -> b) -> b -> DeclaratorOrAbstractDeclarator a -> b

foldr1 :: (a -> a -> a) -> DeclaratorOrAbstractDeclarator a -> a

foldl1 :: (a -> a -> a) -> DeclaratorOrAbstractDeclarator a -> a

toList :: DeclaratorOrAbstractDeclarator a -> [a]

null :: DeclaratorOrAbstractDeclarator a -> Bool

length :: DeclaratorOrAbstractDeclarator a -> Int

elem :: Eq a => a -> DeclaratorOrAbstractDeclarator a -> Bool

maximum :: Ord a => DeclaratorOrAbstractDeclarator a -> a

minimum :: Ord a => DeclaratorOrAbstractDeclarator a -> a

sum :: Num a => DeclaratorOrAbstractDeclarator a -> a

product :: Num a => DeclaratorOrAbstractDeclarator a -> a

Traversable DeclaratorOrAbstractDeclarator

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> DeclaratorOrAbstractDeclarator a -> f (DeclaratorOrAbstractDeclarator b)

sequenceA :: Applicative f => DeclaratorOrAbstractDeclarator (f a) -> f (DeclaratorOrAbstractDeclarator a)

mapM :: Monad m => (a -> m b) -> DeclaratorOrAbstractDeclarator a -> m (DeclaratorOrAbstractDeclarator b)

sequence :: Monad m => DeclaratorOrAbstractDeclarator (m a) -> m (DeclaratorOrAbstractDeclarator a)

Eq i => Eq (DeclaratorOrAbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

(==) :: DeclaratorOrAbstractDeclarator i -> DeclaratorOrAbstractDeclarator i -> Bool

(/=) :: DeclaratorOrAbstractDeclarator i -> DeclaratorOrAbstractDeclarator i -> Bool

Show i => Show (DeclaratorOrAbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> DeclaratorOrAbstractDeclarator i -> ShowS

show :: DeclaratorOrAbstractDeclarator i -> String

showList :: [DeclaratorOrAbstractDeclarator i] -> ShowS

parameter_declaration :: CParser i m => m (ParameterDeclaration i)

parameter_list :: CParser i m => m [ParameterDeclaration i]

data AbstractDeclarator i

Constructors

AbstractDeclarator

Fields

• abstractDeclaratorPointers :: [Pointer]
• abstractDeclaratorDirect :: Maybe (DirectAbstractDeclarator i)

Instances

Functor AbstractDeclarator

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> AbstractDeclarator a -> AbstractDeclarator b

(<$) :: a -> AbstractDeclarator b -> AbstractDeclarator a

Foldable AbstractDeclarator

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => AbstractDeclarator m -> m

foldMap :: Monoid m => (a -> m) -> AbstractDeclarator a -> m

foldr :: (a -> b -> b) -> b -> AbstractDeclarator a -> b

foldr' :: (a -> b -> b) -> b -> AbstractDeclarator a -> b

foldl :: (b -> a -> b) -> b -> AbstractDeclarator a -> b

foldl' :: (b -> a -> b) -> b -> AbstractDeclarator a -> b

foldr1 :: (a -> a -> a) -> AbstractDeclarator a -> a

foldl1 :: (a -> a -> a) -> AbstractDeclarator a -> a

toList :: AbstractDeclarator a -> [a]

null :: AbstractDeclarator a -> Bool

length :: AbstractDeclarator a -> Int

elem :: Eq a => a -> AbstractDeclarator a -> Bool

maximum :: Ord a => AbstractDeclarator a -> a

minimum :: Ord a => AbstractDeclarator a -> a

sum :: Num a => AbstractDeclarator a -> a

product :: Num a => AbstractDeclarator a -> a

Traversable AbstractDeclarator

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> AbstractDeclarator a -> f (AbstractDeclarator b)

sequenceA :: Applicative f => AbstractDeclarator (f a) -> f (AbstractDeclarator a)

mapM :: Monad m => (a -> m b) -> AbstractDeclarator a -> m (AbstractDeclarator b)

sequence :: Monad m => AbstractDeclarator (m a) -> m (AbstractDeclarator a)

Eq i => Eq (AbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

(==) :: AbstractDeclarator i -> AbstractDeclarator i -> Bool

(/=) :: AbstractDeclarator i -> AbstractDeclarator i -> Bool

Show i => Show (AbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> AbstractDeclarator i -> ShowS

show :: AbstractDeclarator i -> String

showList :: [AbstractDeclarator i] -> ShowS

Pretty i => Pretty (AbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

pretty :: AbstractDeclarator i -> Doc

prettyList :: [AbstractDeclarator i] -> Doc

abstract_declarator :: CParser i m => m (AbstractDeclarator i)

data DirectAbstractDeclarator i

Constructors

ArrayOrProtoHere (ArrayOrProto i)

ArrayOrProtoThere (DirectAbstractDeclarator i) (ArrayOrProto i)

AbstractDeclaratorParens (AbstractDeclarator i)

Instances

Functor DirectAbstractDeclarator

Defined in Language.C.Types.Parse

Methods

fmap :: (a -> b) -> DirectAbstractDeclarator a -> DirectAbstractDeclarator b

(<$) :: a -> DirectAbstractDeclarator b -> DirectAbstractDeclarator a

Foldable DirectAbstractDeclarator

Defined in Language.C.Types.Parse

Methods

fold :: Monoid m => DirectAbstractDeclarator m -> m

foldMap :: Monoid m => (a -> m) -> DirectAbstractDeclarator a -> m

foldr :: (a -> b -> b) -> b -> DirectAbstractDeclarator a -> b

foldr' :: (a -> b -> b) -> b -> DirectAbstractDeclarator a -> b

foldl :: (b -> a -> b) -> b -> DirectAbstractDeclarator a -> b

foldl' :: (b -> a -> b) -> b -> DirectAbstractDeclarator a -> b

foldr1 :: (a -> a -> a) -> DirectAbstractDeclarator a -> a

foldl1 :: (a -> a -> a) -> DirectAbstractDeclarator a -> a

toList :: DirectAbstractDeclarator a -> [a]

null :: DirectAbstractDeclarator a -> Bool

length :: DirectAbstractDeclarator a -> Int

elem :: Eq a => a -> DirectAbstractDeclarator a -> Bool

maximum :: Ord a => DirectAbstractDeclarator a -> a

minimum :: Ord a => DirectAbstractDeclarator a -> a

sum :: Num a => DirectAbstractDeclarator a -> a

product :: Num a => DirectAbstractDeclarator a -> a

Traversable DirectAbstractDeclarator

Defined in Language.C.Types.Parse

Methods

traverse :: Applicative f => (a -> f b) -> DirectAbstractDeclarator a -> f (DirectAbstractDeclarator b)

sequenceA :: Applicative f => DirectAbstractDeclarator (f a) -> f (DirectAbstractDeclarator a)

mapM :: Monad m => (a -> m b) -> DirectAbstractDeclarator a -> m (DirectAbstractDeclarator b)

sequence :: Monad m => DirectAbstractDeclarator (m a) -> m (DirectAbstractDeclarator a)

Eq i => Eq (DirectAbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

(==) :: DirectAbstractDeclarator i -> DirectAbstractDeclarator i -> Bool

(/=) :: DirectAbstractDeclarator i -> DirectAbstractDeclarator i -> Bool

Show i => Show (DirectAbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

showsPrec :: Int -> DirectAbstractDeclarator i -> ShowS

show :: DirectAbstractDeclarator i -> String

showList :: [DirectAbstractDeclarator i] -> ShowS

Pretty i => Pretty (DirectAbstractDeclarator i)

Defined in Language.C.Types.Parse

Methods

pretty :: DirectAbstractDeclarator i -> Doc

prettyList :: [DirectAbstractDeclarator i] -> Doc

direct_abstract_declarator :: CParser i m => m (DirectAbstractDeclarator i)

YACC grammar

The parser above is derived from a modification of the YACC grammar for C99 found at http://www.quut.com/c/ANSI-C-grammar-y-1999.html, reproduced below.

%token IDENTIFIER TYPE_NAME INTEGER

%token TYPEDEF EXTERN STATIC AUTO REGISTER INLINE RESTRICT
%token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
%token BOOL COMPLEX IMAGINARY
%token STRUCT UNION ENUM

%start parameter_list
%%

declaration_specifiers
	: storage_class_specifier
	| storage_class_specifier declaration_specifiers
	| type_specifier
	| type_specifier declaration_specifiers
	| type_qualifier
	| type_qualifier declaration_specifiers
	| function_specifier
	| function_specifier declaration_specifiers
	;

storage_class_specifier
	: TYPEDEF
	| EXTERN
	| STATIC
	| AUTO
	| REGISTER
	;

type_specifier
	: VOID
	| CHAR
	| SHORT
	| INT
	| LONG
	| FLOAT
	| DOUBLE
	| SIGNED
	| UNSIGNED
	| BOOL
	| COMPLEX
	| IMAGINARY
 	| STRUCT IDENTIFIER
	| UNION IDENTIFIER
	| ENUM IDENTIFIER
	| TYPE_NAME
	;

type_qualifier
	: CONST
	| RESTRICT
	| VOLATILE
	;

function_specifier
	: INLINE
	;

declarator
	: pointer direct_declarator
	| direct_declarator
	;

direct_declarator
	: IDENTIFIER
	| '(' declarator ')'
	| direct_declarator '[' type_qualifier_list ']'
	| direct_declarator '[' type_qualifier_list * ']'
	| direct_declarator '[' * ']'
 	| direct_declarator '[' IDENTIFIER ']'
	| direct_declarator '[' INTEGER ']'
	| direct_declarator '[' ']'
	| direct_declarator '(' parameter_list ')'
	| direct_declarator '(' ')'
	;

pointer
	: *
	| * type_qualifier_list
	| * pointer
	| * type_qualifier_list pointer
	;

type_qualifier_list
	: type_qualifier
	| type_qualifier_list type_qualifier
	;

parameter_list
	: parameter_declaration
	| parameter_list ',' parameter_declaration
	;

parameter_declaration
	: declaration_specifiers declarator
	| declaration_specifiers abstract_declarator
	| declaration_specifiers
	;

abstract_declarator
	: pointer
	| direct_abstract_declarator
	| pointer direct_abstract_declarator
	;

direct_abstract_declarator
	: '(' abstract_declarator ')'
	| '[' ']'
	| direct_abstract_declarator '[' ']'
	| '[' * ']'
	| direct_abstract_declarator '[' * ']'
	| '[' IDENTIFIER ']'
	| direct_abstract_declarator '[' IDENTIFIER ']'
	| '[' INTEGER ']'
	| direct_abstract_declarator '[' INTEGER ']'
	| '(' ')'
	| '(' parameter_list ')'
	| direct_abstract_declarator '(' ')'
	| direct_abstract_declarator '(' parameter_list ')'
	;

%%
#include <stdio.h>

extern char yytext[];
extern int column;

void yyerror(char const *s)
{
	fflush(stdout);
	printf("n%*sn%*sn", column, "^", column, s);
}

Testing utilities

cIdentStart :: [Char]

cIdentLetter :: [Char]

cReservedWords :: HashSet String

isTypeName :: TypeNames -> String -> Bool